three-stdlib 2.15.1 → 2.15.2

package/geometries/TextGeometry.js

@@ -1,6 +1,7 @@
-import { ExtrudeGeometry } from 'three';
-
-class TextGeometry extends ExtrudeGeometry {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class TextGeometry extends THREE.ExtrudeGeometry {
   constructor(text, parameters) {
     const {
       bevelEnabled = false,
@@ -13,19 +14,10 @@ class TextGeometry extends ExtrudeGeometry {
       letterSpacing = 0,
       ...rest
     } = parameters;
-    const shapes = font.generateShapes(text, size, {
-      lineHeight,
-      letterSpacing
-    });
-    super(shapes, { ...rest,
-      bevelEnabled,
-      bevelSize,
-      bevelThickness,
-      depth: height
-    });
-    this.type = 'TextGeometry';
+    const shapes = font.generateShapes(text, size, { lineHeight, letterSpacing });
+    super(shapes, { ...rest, bevelEnabled, bevelSize, bevelThickness, depth: height });
+    this.type = "TextGeometry";
   }
-
 }
-
-export { TextGeometry as TextBufferGeometry, TextGeometry };
+exports.TextBufferGeometry = TextGeometry;
+exports.TextGeometry = TextGeometry;

package/geometries/TextGeometry.mjs

@@ -0,0 +1,23 @@
+import { ExtrudeGeometry } from "three";
+class TextGeometry extends ExtrudeGeometry {
+  constructor(text, parameters) {
+    const {
+      bevelEnabled = false,
+      bevelSize = 8,
+      bevelThickness = 10,
+      font,
+      height = 50,
+      size = 100,
+      lineHeight = 1,
+      letterSpacing = 0,
+      ...rest
+    } = parameters;
+    const shapes = font.generateShapes(text, size, { lineHeight, letterSpacing });
+    super(shapes, { ...rest, bevelEnabled, bevelSize, bevelThickness, depth: height });
+    this.type = "TextGeometry";
+  }
+}
+export {
+  TextGeometry as TextBufferGeometry,
+  TextGeometry
+};

package/helpers/LightProbeHelper.js

@@ -1,40 +1,72 @@
-import { Mesh, ShaderMaterial, SphereGeometry } from 'three';
-
-class LightProbeHelper extends Mesh {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class LightProbeHelper extends THREE.Mesh {
   constructor(lightProbe, size) {
     this.lightProbe = lightProbe;
     this.size = size;
-    const material = new ShaderMaterial({
-      type: 'LightProbeHelperMaterial',
+    const material = new THREE.ShaderMaterial({
+      type: "LightProbeHelperMaterial",
       uniforms: {
-        sh: {
-          value: this.lightProbe.sh.coefficients
-        },
-        // by reference
-        intensity: {
-          value: this.lightProbe.intensity
-        }
+        sh: { value: this.lightProbe.sh.coefficients },
+        intensity: { value: this.lightProbe.intensity }
       },
-      vertexShader: ['varying vec3 vNormal;', 'void main() {', '	vNormal = normalize( normalMatrix * normal );', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-      fragmentShader: ['#define RECIPROCAL_PI 0.318309886', 'vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {', '	// matrix is assumed to be orthogonal', '	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );', '}', '// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf', 'vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {', '	// normal is assumed to have unit length', '	float x = normal.x, y = normal.y, z = normal.z;', '	// band 0', '	vec3 result = shCoefficients[ 0 ] * 0.886227;', '	// band 1', '	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;', '	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;', '	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;', '	// band 2', '	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;', '	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;', '	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );', '	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;', '	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );', '	return result;', '}', 'uniform vec3 sh[ 9 ]; // sh coefficients', 'uniform float intensity; // light probe intensity', 'varying vec3 vNormal;', 'void main() {', '	vec3 normal = normalize( vNormal );', '	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );', '	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );', '	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;', '	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );', '}'].join('\n')
+      vertexShader: [
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vNormal = normalize( normalMatrix * normal );",
+        "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+        "}"
+      ].join("\n"),
+      fragmentShader: [
+        "#define RECIPROCAL_PI 0.318309886",
+        "vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {",
+        "	// matrix is assumed to be orthogonal",
+        "	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );",
+        "}",
+        "// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf",
+        "vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {",
+        "	// normal is assumed to have unit length",
+        "	float x = normal.x, y = normal.y, z = normal.z;",
+        "	// band 0",
+        "	vec3 result = shCoefficients[ 0 ] * 0.886227;",
+        "	// band 1",
+        "	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;",
+        "	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;",
+        "	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;",
+        "	// band 2",
+        "	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;",
+        "	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;",
+        "	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );",
+        "	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;",
+        "	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );",
+        "	return result;",
+        "}",
+        "uniform vec3 sh[ 9 ]; // sh coefficients",
+        "uniform float intensity; // light probe intensity",
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vec3 normal = normalize( vNormal );",
+        "	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );",
+        "	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );",
+        "	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;",
+        "	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );",
+        "}"
+      ].join("\n")
     });
-    const geometry = new SphereGeometry(1, 32, 16);
+    const geometry = new THREE.SphereGeometry(1, 32, 16);
     super(geometry, material);
-    this.type = 'LightProbeHelper';
+    this.type = "LightProbeHelper";
     this.onBeforeRender();
   }
-
   dispose() {
     this.geometry.dispose();
     this.material.dispose();
   }
-
   onBeforeRender() {
     this.position.copy(this.lightProbe.position);
     this.scale.set(1, 1, 1).multiplyScalar(this.size);
     this.material.uniforms.intensity.value = this.lightProbe.intensity;
   }
-
 }
-
-export { LightProbeHelper };
+exports.LightProbeHelper = LightProbeHelper;

package/helpers/LightProbeHelper.mjs

@@ -0,0 +1,72 @@
+import { Mesh, ShaderMaterial, SphereGeometry } from "three";
+class LightProbeHelper extends Mesh {
+  constructor(lightProbe, size) {
+    this.lightProbe = lightProbe;
+    this.size = size;
+    const material = new ShaderMaterial({
+      type: "LightProbeHelperMaterial",
+      uniforms: {
+        sh: { value: this.lightProbe.sh.coefficients },
+        intensity: { value: this.lightProbe.intensity }
+      },
+      vertexShader: [
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vNormal = normalize( normalMatrix * normal );",
+        "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+        "}"
+      ].join("\n"),
+      fragmentShader: [
+        "#define RECIPROCAL_PI 0.318309886",
+        "vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {",
+        "	// matrix is assumed to be orthogonal",
+        "	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );",
+        "}",
+        "// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf",
+        "vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {",
+        "	// normal is assumed to have unit length",
+        "	float x = normal.x, y = normal.y, z = normal.z;",
+        "	// band 0",
+        "	vec3 result = shCoefficients[ 0 ] * 0.886227;",
+        "	// band 1",
+        "	result += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;",
+        "	result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;",
+        "	result += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;",
+        "	// band 2",
+        "	result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;",
+        "	result += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;",
+        "	result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );",
+        "	result += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;",
+        "	result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );",
+        "	return result;",
+        "}",
+        "uniform vec3 sh[ 9 ]; // sh coefficients",
+        "uniform float intensity; // light probe intensity",
+        "varying vec3 vNormal;",
+        "void main() {",
+        "	vec3 normal = normalize( vNormal );",
+        "	vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );",
+        "	vec3 irradiance = shGetIrradianceAt( worldNormal, sh );",
+        "	vec3 outgoingLight = RECIPROCAL_PI * irradiance * intensity;",
+        "	gl_FragColor = linearToOutputTexel( vec4( outgoingLight, 1.0 ) );",
+        "}"
+      ].join("\n")
+    });
+    const geometry = new SphereGeometry(1, 32, 16);
+    super(geometry, material);
+    this.type = "LightProbeHelper";
+    this.onBeforeRender();
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+  onBeforeRender() {
+    this.position.copy(this.lightProbe.position);
+    this.scale.set(1, 1, 1).multiplyScalar(this.size);
+    this.material.uniforms.intensity.value = this.lightProbe.intensity;
+  }
+}
+export {
+  LightProbeHelper
+};

package/helpers/PositionalAudioHelper.js

@@ -1,33 +1,29 @@
-import { Line, BufferGeometry, BufferAttribute, LineBasicMaterial, MathUtils } from 'three';
-
-class PositionalAudioHelper extends Line {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class PositionalAudioHelper extends THREE.Line {
   constructor(audio, range, divisionsInnerAngle, divisionsOuterAngle) {
     this.audio = audio;
     this.range = range || 1;
     this.divisionsInnerAngle = divisionsInnerAngle || 16;
     this.divisionsOuterAngle = divisionsOuterAngle || 2;
-    const geometry = new BufferGeometry();
+    const geometry = new THREE.BufferGeometry();
     const divisions = this.divisionsInnerAngle + this.divisionsOuterAngle * 2;
     const positions = new Float32Array((divisions * 3 + 3) * 3);
-    geometry.setAttribute('position', new BufferAttribute(positions, 3));
-    const materialInnerAngle = new LineBasicMaterial({
-      color: 0x00ff00
-    });
-    const materialOuterAngle = new LineBasicMaterial({
-      color: 0xffff00
-    });
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    const materialInnerAngle = new THREE.LineBasicMaterial({ color: 65280 });
+    const materialOuterAngle = new THREE.LineBasicMaterial({ color: 16776960 });
     super(geometry, [materialOuterAngle, materialInnerAngle]);
-    this.type = 'PositionalAudioHelper';
+    this.type = "PositionalAudioHelper";
     this.update();
   }
-
   update() {
     const audio = this.audio;
     const range = this.range;
     const divisionsInnerAngle = this.divisionsInnerAngle;
     const divisionsOuterAngle = this.divisionsOuterAngle;
-    const coneInnerAngle = MathUtils.degToRad(audio.panner.coneInnerAngle);
-    const coneOuterAngle = MathUtils.degToRad(audio.panner.coneOuterAngle);
+    const coneInnerAngle = THREE.MathUtils.degToRad(audio.panner.coneInnerAngle);
+    const coneOuterAngle = THREE.MathUtils.degToRad(audio.panner.coneOuterAngle);
     const halfConeInnerAngle = coneInnerAngle / 2;
     const halfConeOuterAngle = coneOuterAngle / 2;
     let start = 0;
@@ -35,41 +31,38 @@ class PositionalAudioHelper extends Line {
     let i, stride;
     const geometry = this.geometry;
     const positionAttribute = geometry.attributes.position;
-    geometry.clearGroups(); //
-
+    geometry.clearGroups();
     function generateSegment(from, to, divisions, materialIndex) {
       const step = (to - from) / divisions;
       positionAttribute.setXYZ(start, 0, 0, 0);
       count++;
-
       for (i = from; i < to; i += step) {
         stride = start + count;
         positionAttribute.setXYZ(stride, Math.sin(i) * range, 0, Math.cos(i) * range);
-        positionAttribute.setXYZ(stride + 1, Math.sin(Math.min(i + step, to)) * range, 0, Math.cos(Math.min(i + step, to)) * range);
+        positionAttribute.setXYZ(
+          stride + 1,
+          Math.sin(Math.min(i + step, to)) * range,
+          0,
+          Math.cos(Math.min(i + step, to)) * range
+        );
         positionAttribute.setXYZ(stride + 2, 0, 0, 0);
         count += 3;
       }
-
       geometry.addGroup(start, count, materialIndex);
       start += count;
       count = 0;
-    } //
-
-
+    }
     generateSegment(-halfConeOuterAngle, -halfConeInnerAngle, divisionsOuterAngle, 0);
     generateSegment(-halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1);
-    generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0); //
-
+    generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0);
     positionAttribute.needsUpdate = true;
-    if (coneInnerAngle === coneOuterAngle) this.material[0].visible = false;
+    if (coneInnerAngle === coneOuterAngle)
+      this.material[0].visible = false;
   }
-
   dispose() {
     this.geometry.dispose();
     this.material[0].dispose();
     this.material[1].dispose();
   }
-
 }
-
-export { PositionalAudioHelper };
+exports.PositionalAudioHelper = PositionalAudioHelper;

package/helpers/PositionalAudioHelper.mjs

@@ -0,0 +1,68 @@
+import { Line, BufferGeometry, BufferAttribute, LineBasicMaterial, MathUtils } from "three";
+class PositionalAudioHelper extends Line {
+  constructor(audio, range, divisionsInnerAngle, divisionsOuterAngle) {
+    this.audio = audio;
+    this.range = range || 1;
+    this.divisionsInnerAngle = divisionsInnerAngle || 16;
+    this.divisionsOuterAngle = divisionsOuterAngle || 2;
+    const geometry = new BufferGeometry();
+    const divisions = this.divisionsInnerAngle + this.divisionsOuterAngle * 2;
+    const positions = new Float32Array((divisions * 3 + 3) * 3);
+    geometry.setAttribute("position", new BufferAttribute(positions, 3));
+    const materialInnerAngle = new LineBasicMaterial({ color: 65280 });
+    const materialOuterAngle = new LineBasicMaterial({ color: 16776960 });
+    super(geometry, [materialOuterAngle, materialInnerAngle]);
+    this.type = "PositionalAudioHelper";
+    this.update();
+  }
+  update() {
+    const audio = this.audio;
+    const range = this.range;
+    const divisionsInnerAngle = this.divisionsInnerAngle;
+    const divisionsOuterAngle = this.divisionsOuterAngle;
+    const coneInnerAngle = MathUtils.degToRad(audio.panner.coneInnerAngle);
+    const coneOuterAngle = MathUtils.degToRad(audio.panner.coneOuterAngle);
+    const halfConeInnerAngle = coneInnerAngle / 2;
+    const halfConeOuterAngle = coneOuterAngle / 2;
+    let start = 0;
+    let count = 0;
+    let i, stride;
+    const geometry = this.geometry;
+    const positionAttribute = geometry.attributes.position;
+    geometry.clearGroups();
+    function generateSegment(from, to, divisions, materialIndex) {
+      const step = (to - from) / divisions;
+      positionAttribute.setXYZ(start, 0, 0, 0);
+      count++;
+      for (i = from; i < to; i += step) {
+        stride = start + count;
+        positionAttribute.setXYZ(stride, Math.sin(i) * range, 0, Math.cos(i) * range);
+        positionAttribute.setXYZ(
+          stride + 1,
+          Math.sin(Math.min(i + step, to)) * range,
+          0,
+          Math.cos(Math.min(i + step, to)) * range
+        );
+        positionAttribute.setXYZ(stride + 2, 0, 0, 0);
+        count += 3;
+      }
+      geometry.addGroup(start, count, materialIndex);
+      start += count;
+      count = 0;
+    }
+    generateSegment(-halfConeOuterAngle, -halfConeInnerAngle, divisionsOuterAngle, 0);
+    generateSegment(-halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1);
+    generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0);
+    positionAttribute.needsUpdate = true;
+    if (coneInnerAngle === coneOuterAngle)
+      this.material[0].visible = false;
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material[0].dispose();
+    this.material[1].dispose();
+  }
+}
+export {
+  PositionalAudioHelper
+};

package/helpers/RectAreaLightHelper.js

@@ -1,60 +1,44 @@
-import { Line, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Mesh, MeshBasicMaterial, BackSide } from 'three';
-
-/**
- *  This helper must be added as a child of the light
- */
-
-class RectAreaLightHelper extends Line {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class RectAreaLightHelper extends THREE.Line {
   constructor(light, color) {
     this.light = light;
-    this.color = color; // optional hardwired color for the helper
-
+    this.color = color;
     const positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
-    const geometry = new BufferGeometry();
-    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
     geometry.computeBoundingSphere();
-    const material = new LineBasicMaterial({
-      fog: false
-    });
+    const material = new THREE.LineBasicMaterial({ fog: false });
     super(geometry, material);
-    this.type = 'RectAreaLightHelper'; //
-
+    this.type = "RectAreaLightHelper";
     const positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
-    const geometry2 = new BufferGeometry();
-    geometry2.setAttribute('position', new Float32BufferAttribute(positions2, 3));
+    const geometry2 = new THREE.BufferGeometry();
+    geometry2.setAttribute("position", new THREE.Float32BufferAttribute(positions2, 3));
     geometry2.computeBoundingSphere();
-    this.add(new Mesh(geometry2, new MeshBasicMaterial({
-      side: BackSide,
-      fog: false
-    })));
+    this.add(new THREE.Mesh(geometry2, new THREE.MeshBasicMaterial({ side: THREE.BackSide, fog: false })));
   }
-
   updateMatrixWorld() {
     this.scale.set(0.5 * this.light.width, 0.5 * this.light.height, 1);
-
-    if (this.color !== undefined) {
+    if (this.color !== void 0) {
       this.material.color.set(this.color);
       this.children[0].material.color.set(this.color);
     } else {
-      this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity); // prevent hue shift
-
+      this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);
       const c = this.material.color;
       const max = Math.max(c.r, c.g, c.b);
-      if (max > 1) c.multiplyScalar(1 / max);
+      if (max > 1)
+        c.multiplyScalar(1 / max);
       this.children[0].material.color.copy(this.material.color);
     }
-
     this.matrixWorld.copy(this.light.matrixWorld).scale(this.scale);
     this.children[0].matrixWorld.copy(this.matrixWorld);
   }
-
   dispose() {
     this.geometry.dispose();
     this.material.dispose();
     this.children[0].geometry.dispose();
     this.children[0].material.dispose();
   }
-
 }
-
-export { RectAreaLightHelper };
+exports.RectAreaLightHelper = RectAreaLightHelper;

package/helpers/RectAreaLightHelper.mjs

@@ -0,0 +1,44 @@
+import { Line, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Mesh, MeshBasicMaterial, BackSide } from "three";
+class RectAreaLightHelper extends Line {
+  constructor(light, color) {
+    this.light = light;
+    this.color = color;
+    const positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
+    const geometry = new BufferGeometry();
+    geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+    geometry.computeBoundingSphere();
+    const material = new LineBasicMaterial({ fog: false });
+    super(geometry, material);
+    this.type = "RectAreaLightHelper";
+    const positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
+    const geometry2 = new BufferGeometry();
+    geometry2.setAttribute("position", new Float32BufferAttribute(positions2, 3));
+    geometry2.computeBoundingSphere();
+    this.add(new Mesh(geometry2, new MeshBasicMaterial({ side: BackSide, fog: false })));
+  }
+  updateMatrixWorld() {
+    this.scale.set(0.5 * this.light.width, 0.5 * this.light.height, 1);
+    if (this.color !== void 0) {
+      this.material.color.set(this.color);
+      this.children[0].material.color.set(this.color);
+    } else {
+      this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);
+      const c = this.material.color;
+      const max = Math.max(c.r, c.g, c.b);
+      if (max > 1)
+        c.multiplyScalar(1 / max);
+      this.children[0].material.color.copy(this.material.color);
+    }
+    this.matrixWorld.copy(this.light.matrixWorld).scale(this.scale);
+    this.children[0].matrixWorld.copy(this.matrixWorld);
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+    this.children[0].geometry.dispose();
+    this.children[0].material.dispose();
+  }
+}
+export {
+  RectAreaLightHelper
+};

package/helpers/VertexNormalsHelper.js

@@ -1,75 +1,54 @@
-import { Vector3, Matrix3, LineSegments, BufferGeometry, LineBasicMaterial, Float32BufferAttribute } from 'three';
-
-const _v1 = new Vector3();
-
-const _v2 = new Vector3();
-
-const _normalMatrix = new Matrix3();
-
-class VertexNormalsHelper extends LineSegments {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const _v1 = new THREE.Vector3();
+const _v2 = new THREE.Vector3();
+const _normalMatrix = new THREE.Matrix3();
+class VertexNormalsHelper extends THREE.LineSegments {
   constructor(object, size, hex) {
-    const geometry = new BufferGeometry();
-    const color = hex !== undefined ? hex : 0xff0000;
-    super(geometry, new LineBasicMaterial({
-      color,
-      toneMapped: false
-    }));
+    const geometry = new THREE.BufferGeometry();
+    const color = hex !== void 0 ? hex : 16711680;
+    super(geometry, new THREE.LineBasicMaterial({ color, toneMapped: false }));
     this.object = object;
-    this.size = size !== undefined ? size : 0.1;
+    this.size = size !== void 0 ? size : 0.1;
     let nNormals = 0;
     const objGeometry = this.object.geometry;
-
     if (objGeometry && objGeometry.isGeometry) {
-      console.error('THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.');
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
       return;
     } else if (objGeometry && objGeometry.isBufferGeometry) {
       nNormals = objGeometry.attributes.normal.count;
-    } //
-
-
-    const positions = new Float32BufferAttribute(nNormals * 2 * 3, 3);
-    geometry.setAttribute('position', positions);
-    this.type = 'VertexNormalsHelper'; //
-
+    }
+    const positions = new THREE.Float32BufferAttribute(nNormals * 2 * 3, 3);
+    geometry.setAttribute("position", positions);
+    this.type = "VertexNormalsHelper";
     this.matrixAutoUpdate = false;
     this.update();
   }
-
   update() {
     this.object.updateMatrixWorld(true);
-
     _normalMatrix.getNormalMatrix(this.object.matrixWorld);
-
     const matrixWorld = this.object.matrixWorld;
-    const position = this.geometry.attributes.position; //
-
+    const position = this.geometry.attributes.position;
     const objGeometry = this.object.geometry;
-
     if (objGeometry && objGeometry.isGeometry) {
-      console.error('THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.');
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
       return;
     } else if (objGeometry && objGeometry.isBufferGeometry) {
       const objPos = objGeometry.attributes.position;
       const objNorm = objGeometry.attributes.normal;
-      let idx = 0; // for simplicity, ignore index and drawcalls, and render every normal
-
+      let idx = 0;
       for (let j = 0, jl = objPos.count; j < jl; j++) {
         _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
-
         _v2.set(objNorm.getX(j), objNorm.getY(j), objNorm.getZ(j));
-
         _v2.applyMatrix3(_normalMatrix).normalize().multiplyScalar(this.size).add(_v1);
-
         position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
         idx = idx + 1;
         position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
         idx = idx + 1;
       }
     }
-
     position.needsUpdate = true;
   }
-
 }
-
-export { VertexNormalsHelper };
+exports.VertexNormalsHelper = VertexNormalsHelper;

package/helpers/VertexNormalsHelper.mjs

@@ -0,0 +1,54 @@
+import { Vector3, Matrix3, LineSegments, BufferGeometry, LineBasicMaterial, Float32BufferAttribute } from "three";
+const _v1 = new Vector3();
+const _v2 = new Vector3();
+const _normalMatrix = new Matrix3();
+class VertexNormalsHelper extends LineSegments {
+  constructor(object, size, hex) {
+    const geometry = new BufferGeometry();
+    const color = hex !== void 0 ? hex : 16711680;
+    super(geometry, new LineBasicMaterial({ color, toneMapped: false }));
+    this.object = object;
+    this.size = size !== void 0 ? size : 0.1;
+    let nNormals = 0;
+    const objGeometry = this.object.geometry;
+    if (objGeometry && objGeometry.isGeometry) {
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
+      return;
+    } else if (objGeometry && objGeometry.isBufferGeometry) {
+      nNormals = objGeometry.attributes.normal.count;
+    }
+    const positions = new Float32BufferAttribute(nNormals * 2 * 3, 3);
+    geometry.setAttribute("position", positions);
+    this.type = "VertexNormalsHelper";
+    this.matrixAutoUpdate = false;
+    this.update();
+  }
+  update() {
+    this.object.updateMatrixWorld(true);
+    _normalMatrix.getNormalMatrix(this.object.matrixWorld);
+    const matrixWorld = this.object.matrixWorld;
+    const position = this.geometry.attributes.position;
+    const objGeometry = this.object.geometry;
+    if (objGeometry && objGeometry.isGeometry) {
+      console.error("THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.");
+      return;
+    } else if (objGeometry && objGeometry.isBufferGeometry) {
+      const objPos = objGeometry.attributes.position;
+      const objNorm = objGeometry.attributes.normal;
+      let idx = 0;
+      for (let j = 0, jl = objPos.count; j < jl; j++) {
+        _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
+        _v2.set(objNorm.getX(j), objNorm.getY(j), objNorm.getZ(j));
+        _v2.applyMatrix3(_normalMatrix).normalize().multiplyScalar(this.size).add(_v1);
+        position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
+        idx = idx + 1;
+        position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
+        idx = idx + 1;
+      }
+    }
+    position.needsUpdate = true;
+  }
+}
+export {
+  VertexNormalsHelper
+};