viral-viewer-2 2.2.2 → 2.2.4

package/dist/components/worker-script/load-model-worker-2.script.js

@@ -82,22 +82,30 @@ function workerFunction() {
             case 1:
                 console.log('receive structural');
                 progressStructuralGeometries(event.data.materials, event.data.data, (buffer, colorString, opacity) => {
+                    const geometry = new BufferGeometry();
+                    geometry.setAttribute("position", new BufferAttribute(buffer, 3));
+                    geometry.computeVertexNormals();
                     self.postMessage({
                         type: 1,
                         buffer: buffer,
                         materialColorString: colorString,
                         materialOpacity: opacity,
+                        geometry: geometry
                     });
                 });
                 break;
             case 2:
                 console.log('receive none structural');
                 progressNoneStructuralGeometries(event.data.materials, event.data.data, (buffer, colorString, opacity) => {
+                    const geometry = new BufferGeometry();
+                    geometry.setAttribute("position", new BufferAttribute(buffer, 3));
+                    geometry.computeVertexNormals();
                     self.postMessage({
                         type: 1,
                         buffer: buffer,
                         materialColorString: colorString,
                         materialOpacity: opacity,
+                        geometry: geometry
                     });
                 });
                 break;
@@ -106,166 +114,7 @@ function workerFunction() {
         }
     }, false);
     //#region Threejs Types
-    const REVISION = '135';
-    const CullFaceNone = 0;
-    const CullFaceBack = 1;
-    const CullFaceFront = 2;
-    const PCFShadowMap = 1;
-    const PCFSoftShadowMap = 2;
-    const VSMShadowMap = 3;
-    const FrontSide = 0;
-    const BackSide = 1;
-    const DoubleSide = 2;
-    const FlatShading = 1;
-    const NoBlending = 0;
-    const NormalBlending = 1;
-    const AdditiveBlending = 2;
-    const SubtractiveBlending = 3;
-    const MultiplyBlending = 4;
-    const CustomBlending = 5;
-    const AddEquation = 100;
-    const SubtractEquation = 101;
-    const ReverseSubtractEquation = 102;
-    const MinEquation = 103;
-    const MaxEquation = 104;
-    const ZeroFactor = 200;
-    const OneFactor = 201;
-    const SrcColorFactor = 202;
-    const OneMinusSrcColorFactor = 203;
-    const SrcAlphaFactor = 204;
-    const OneMinusSrcAlphaFactor = 205;
-    const DstAlphaFactor = 206;
-    const OneMinusDstAlphaFactor = 207;
-    const DstColorFactor = 208;
-    const OneMinusDstColorFactor = 209;
-    const SrcAlphaSaturateFactor = 210;
-    const NeverDepth = 0;
-    const AlwaysDepth = 1;
-    const LessDepth = 2;
-    const LessEqualDepth = 3;
-    const EqualDepth = 4;
-    const GreaterEqualDepth = 5;
-    const GreaterDepth = 6;
-    const NotEqualDepth = 7;
-    const MultiplyOperation = 0;
-    const MixOperation = 1;
-    const AddOperation = 2;
-    const NoToneMapping = 0;
-    const LinearToneMapping = 1;
-    const ReinhardToneMapping = 2;
-    const CineonToneMapping = 3;
-    const ACESFilmicToneMapping = 4;
-    const CustomToneMapping = 5;
-    const UVMapping = 300;
-    const CubeReflectionMapping = 301;
-    const CubeRefractionMapping = 302;
-    const EquirectangularReflectionMapping = 303;
-    const EquirectangularRefractionMapping = 304;
-    const CubeUVReflectionMapping = 306;
-    const CubeUVRefractionMapping = 307;
-    const RepeatWrapping = 1000;
-    const ClampToEdgeWrapping = 1001;
-    const MirroredRepeatWrapping = 1002;
-    const NearestFilter = 1003;
-    const NearestMipmapNearestFilter = 1004;
-    const NearestMipmapLinearFilter = 1005;
-    const LinearFilter = 1006;
-    const LinearMipmapNearestFilter = 1007;
-    const LinearMipmapLinearFilter = 1008;
-    const UnsignedByteType = 1009;
-    const ByteType = 1010;
-    const ShortType = 1011;
-    const UnsignedShortType = 1012;
-    const IntType = 1013;
-    const UnsignedIntType = 1014;
-    const FloatType = 1015;
-    const HalfFloatType = 1016;
-    const UnsignedShort4444Type = 1017;
-    const UnsignedShort5551Type = 1018;
-    const UnsignedShort565Type = 1019;
-    const UnsignedInt248Type = 1020;
-    const AlphaFormat = 1021;
-    const RGBFormat = 1022;
-    const RGBAFormat = 1023;
-    const LuminanceFormat = 1024;
-    const LuminanceAlphaFormat = 1025;
-    const RGBEFormat = RGBAFormat;
-    const DepthFormat = 1026;
-    const DepthStencilFormat = 1027;
-    const RedFormat = 1028;
-    const RedIntegerFormat = 1029;
-    const RGFormat = 1030;
-    const RGIntegerFormat = 1031;
-    const RGBIntegerFormat = 1032;
-    const RGBAIntegerFormat = 1033;
-    const RGB_S3TC_DXT1_Format = 33776;
-    const RGBA_S3TC_DXT1_Format = 33777;
-    const RGBA_S3TC_DXT3_Format = 33778;
-    const RGBA_S3TC_DXT5_Format = 33779;
-    const RGB_PVRTC_4BPPV1_Format = 35840;
-    const RGB_PVRTC_2BPPV1_Format = 35841;
-    const RGBA_PVRTC_4BPPV1_Format = 35842;
-    const RGBA_PVRTC_2BPPV1_Format = 35843;
-    const RGB_ETC1_Format = 36196;
-    const RGB_ETC2_Format = 37492;
-    const RGBA_ETC2_EAC_Format = 37496;
-    const RGBA_ASTC_4x4_Format = 37808;
-    const RGBA_ASTC_5x4_Format = 37809;
-    const RGBA_ASTC_5x5_Format = 37810;
-    const RGBA_ASTC_6x5_Format = 37811;
-    const RGBA_ASTC_6x6_Format = 37812;
-    const RGBA_ASTC_8x5_Format = 37813;
-    const RGBA_ASTC_8x6_Format = 37814;
-    const RGBA_ASTC_8x8_Format = 37815;
-    const RGBA_ASTC_10x5_Format = 37816;
-    const RGBA_ASTC_10x6_Format = 37817;
-    const RGBA_ASTC_10x8_Format = 37818;
-    const RGBA_ASTC_10x10_Format = 37819;
-    const RGBA_ASTC_12x10_Format = 37820;
-    const RGBA_ASTC_12x12_Format = 37821;
-    const RGBA_BPTC_Format = 36492;
-    const SRGB8_ALPHA8_ASTC_4x4_Format = 37840;
-    const SRGB8_ALPHA8_ASTC_5x4_Format = 37841;
-    const SRGB8_ALPHA8_ASTC_5x5_Format = 37842;
-    const SRGB8_ALPHA8_ASTC_6x5_Format = 37843;
-    const SRGB8_ALPHA8_ASTC_6x6_Format = 37844;
-    const SRGB8_ALPHA8_ASTC_8x5_Format = 37845;
-    const SRGB8_ALPHA8_ASTC_8x6_Format = 37846;
-    const SRGB8_ALPHA8_ASTC_8x8_Format = 37847;
-    const SRGB8_ALPHA8_ASTC_10x5_Format = 37848;
-    const SRGB8_ALPHA8_ASTC_10x6_Format = 37849;
-    const SRGB8_ALPHA8_ASTC_10x8_Format = 37850;
-    const SRGB8_ALPHA8_ASTC_10x10_Format = 37851;
-    const SRGB8_ALPHA8_ASTC_12x10_Format = 37852;
-    const SRGB8_ALPHA8_ASTC_12x12_Format = 37853;
-    const LoopOnce = 2200;
-    const LoopRepeat = 2201;
-    const LoopPingPong = 2202;
-    const InterpolateDiscrete = 2300;
-    const InterpolateLinear = 2301;
-    const InterpolateSmooth = 2302;
-    const ZeroCurvatureEnding = 2400;
-    const ZeroSlopeEnding = 2401;
-    const WrapAroundEnding = 2402;
-    const NormalAnimationBlendMode = 2500;
-    const AdditiveAnimationBlendMode = 2501;
-    const TrianglesDrawMode = 0;
-    const LinearEncoding = 3000;
-    const sRGBEncoding = 3001;
-    const GammaEncoding = 3007;
-    const RGBEEncoding = 3002;
-    const RGBM7Encoding = 3004;
-    const RGBM16Encoding = 3005;
-    const RGBDEncoding = 3006;
-    const BasicDepthPacking = 3200;
-    const RGBADepthPacking = 3201;
-    const TangentSpaceNormalMap = 0;
-    const ObjectSpaceNormalMap = 1;
-    const KeepStencilOp = 7680;
-    const AlwaysStencilFunc = 519;
     const StaticDrawUsage = 35044;
-    const DynamicDrawUsage = 35048;
-    const GLSL3 = '300 es';
     class EventDispatcher {
         constructor() {
             this._listeners = {};
@@ -726,17 +575,6 @@ function workerFunction() {
     }
     //#endregion
     //#region Base Unit
-    class Matrix4 {
-        constructor() {
-            this.elements = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-        }
-        fromArray(array, offset = 0) {
-            for (let i = 0; i < 16; i++) {
-                this.elements[i] = array[i + offset];
-            }
-            return this;
-        }
-    }
     class Vector2 {
         constructor(x = 0, y = 0) {
             this.x = x;
@@ -1212,6 +1050,62 @@ function workerFunction() {
             this.z = e[2] * x + e[6] * y + e[10] * z;
             return this.normalize();
         }
+        min(v) {
+            this.x = Math.min(this.x, v.x);
+            this.y = Math.min(this.y, v.y);
+            this.z = Math.min(this.z, v.z);
+            return this;
+        }
+        max(v) {
+            this.x = Math.max(this.x, v.x);
+            this.y = Math.max(this.y, v.y);
+            this.z = Math.max(this.z, v.z);
+            return this;
+        }
+        dot(v) {
+            return this.x * v.x + this.y * v.y + this.z * v.z;
+        }
+        distanceToSquared(v) {
+            const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+            return dx * dx + dy * dy + dz * dz;
+        }
+        distanceTo(v) {
+            return Math.sqrt(this.distanceToSquared(v));
+        }
+        lengthSq() {
+            return this.x * this.x + this.y * this.y + this.z * this.z;
+        }
+        equals(v) {
+            return ((v.x === this.x) && (v.y === this.y) && (v.z === this.z));
+        }
+        negate() {
+            this.x = -this.x;
+            this.y = -this.y;
+            this.z = -this.z;
+            return this;
+        }
+        cross(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.');
+                return this.crossVectors(v, w);
+            }
+            return this.crossVectors(this, v);
+        }
+        crossVectors(a, b) {
+            const ax = a.x, ay = a.y, az = a.z;
+            const bx = b.x, by = b.y, bz = b.z;
+            this.x = ay * bz - az * by;
+            this.y = az * bx - ax * bz;
+            this.z = ax * by - ay * bx;
+            return this;
+        }
+        clamp(min, max) {
+            // assumes min < max, componentwise
+            this.x = Math.max(min.x, Math.min(max.x, this.x));
+            this.y = Math.max(min.y, Math.min(max.y, this.y));
+            this.z = Math.max(min.z, Math.min(max.z, this.z));
+            return this;
+        }
     }
     class Vector4 {
         constructor(x = 0, y = 0, z = 0, w = 1) {
@@ -1791,11 +1685,738 @@ function workerFunction() {
             return new Matrix3().fromArray(this.elements);
         }
     }
+    class Matrix4 {
+        constructor() {
+            this.elements = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        }
+        fromArray(array, offset = 0) {
+            for (let i = 0; i < 16; i++) {
+                this.elements[i] = array[i + offset];
+            }
+            return this;
+        }
+        getMaxScaleOnAxis() {
+            const te = this.elements;
+            const scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2];
+            const scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6];
+            const scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10];
+            return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
+        }
+    }
+    class Box3 {
+        constructor(min = new Vector3(+Infinity, +Infinity, +Infinity), max = new Vector3(-Infinity, -Infinity, -Infinity)) {
+            this.min = min;
+            this.max = max;
+        }
+        set(min, max) {
+            this.min.copy(min);
+            this.max.copy(max);
+            return this;
+        }
+        setFromArray(array) {
+            let minX = +Infinity;
+            let minY = +Infinity;
+            let minZ = +Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            let maxZ = -Infinity;
+            for (let i = 0, l = array.length; i < l; i += 3) {
+                const x = array[i];
+                const y = array[i + 1];
+                const z = array[i + 2];
+                if (x < minX)
+                    minX = x;
+                if (y < minY)
+                    minY = y;
+                if (z < minZ)
+                    minZ = z;
+                if (x > maxX)
+                    maxX = x;
+                if (y > maxY)
+                    maxY = y;
+                if (z > maxZ)
+                    maxZ = z;
+            }
+            this.min.set(minX, minY, minZ);
+            this.max.set(maxX, maxY, maxZ);
+            return this;
+        }
+        setFromBufferAttribute(attribute) {
+            let minX = +Infinity;
+            let minY = +Infinity;
+            let minZ = +Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            let maxZ = -Infinity;
+            for (let i = 0, l = attribute.count; i < l; i++) {
+                const x = attribute.getX(i);
+                const y = attribute.getY(i);
+                const z = attribute.getZ(i);
+                if (x < minX)
+                    minX = x;
+                if (y < minY)
+                    minY = y;
+                if (z < minZ)
+                    minZ = z;
+                if (x > maxX)
+                    maxX = x;
+                if (y > maxY)
+                    maxY = y;
+                if (z > maxZ)
+                    maxZ = z;
+            }
+            this.min.set(minX, minY, minZ);
+            this.max.set(maxX, maxY, maxZ);
+            return this;
+        }
+        setFromPoints(points) {
+            this.makeEmpty();
+            for (let i = 0, il = points.length; i < il; i++) {
+                this.expandByPoint(points[i]);
+            }
+            return this;
+        }
+        setFromCenterAndSize(center, size) {
+            const halfSize = new Vector3().copy(size).multiplyScalar(0.5);
+            this.min.copy(center).sub(halfSize);
+            this.max.copy(center).add(halfSize);
+            return this;
+        }
+        setFromObject(object) {
+            this.makeEmpty();
+            return this.expandByObject(object);
+        }
+        clone() {
+            return new Box3().copy(this);
+        }
+        copy(box) {
+            this.min.copy(box.min);
+            this.max.copy(box.max);
+            return this;
+        }
+        makeEmpty() {
+            this.min.x = this.min.y = this.min.z = +Infinity;
+            this.max.x = this.max.y = this.max.z = -Infinity;
+            return this;
+        }
+        isEmpty() {
+            return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z;
+        }
+        getCenter(target) {
+            return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5);
+        }
+        getSize(target) {
+            return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min);
+        }
+        expandByPoint(point) {
+            this.min.min(point);
+            this.max.max(point);
+            return this;
+        }
+        expandByVector(vector) {
+            this.min.sub(vector);
+            this.max.add(vector);
+            return this;
+        }
+        expandByScalar(scalar) {
+            this.min.addScalar(-scalar);
+            this.max.addScalar(scalar);
+            return this;
+        }
+        expandByObject(object) {
+            object.updateWorldMatrix(false, false);
+            const geometry = object.geometry;
+            if (geometry !== undefined) {
+                if (geometry.boundingBox === null) {
+                    geometry.computeBoundingBox();
+                }
+                const box = new Box3().copy(geometry.boundingBox);
+                box.applyMatrix4(object.matrixWorld);
+                this.union(box);
+            }
+            const children = object.children;
+            for (let i = 0, l = children.length; i < l; i++) {
+                this.expandByObject(children[i]);
+            }
+            return this;
+        }
+        containsPoint(point) {
+            return point.x < this.min.x || point.x > this.max.x ||
+                point.y < this.min.y || point.y > this.max.y ||
+                point.z < this.min.z || point.z > this.max.z ? false : true;
+        }
+        containsBox(box) {
+            return this.min.x <= box.min.x && box.max.x <= this.max.x &&
+                this.min.y <= box.min.y && box.max.y <= this.max.y &&
+                this.min.z <= box.min.z && box.max.z <= this.max.z;
+        }
+        getParameter(point, target) {
+            return target.set((point.x - this.min.x) / (this.max.x - this.min.x), (point.y - this.min.y) / (this.max.y - this.min.y), (point.z - this.min.z) / (this.max.z - this.min.z));
+        }
+        intersectsBox(box) {
+            return box.max.x < this.min.x || box.min.x > this.max.x ||
+                box.max.y < this.min.y || box.min.y > this.max.y ||
+                box.max.z < this.min.z || box.min.z > this.max.z ? false : true;
+        }
+        intersectsSphere(sphere) {
+            this.clampPoint(sphere.center, _vector$b);
+            return _vector$b.distanceToSquared(sphere.center) <= (sphere.radius * sphere.radius);
+        }
+        intersectsPlane(plane) {
+            let min, max;
+            if (plane.normal.x > 0) {
+                min = plane.normal.x * this.min.x;
+                max = plane.normal.x * this.max.x;
+            }
+            else {
+                min = plane.normal.x * this.max.x;
+                max = plane.normal.x * this.min.x;
+            }
+            if (plane.normal.y > 0) {
+                min += plane.normal.y * this.min.y;
+                max += plane.normal.y * this.max.y;
+            }
+            else {
+                min += plane.normal.y * this.max.y;
+                max += plane.normal.y * this.min.y;
+            }
+            if (plane.normal.z > 0) {
+                min += plane.normal.z * this.min.z;
+                max += plane.normal.z * this.max.z;
+            }
+            else {
+                min += plane.normal.z * this.max.z;
+                max += plane.normal.z * this.min.z;
+            }
+            return (min <= -plane.constant && max >= -plane.constant);
+        }
+        intersectsTriangle(triangle) {
+            if (this.isEmpty()) {
+                return false;
+            }
+            this.getCenter(_center);
+            _extents.subVectors(this.max, _center);
+            _v0$2.subVectors(triangle.a, _center);
+            _v1$7.subVectors(triangle.b, _center);
+            _v2$3.subVectors(triangle.c, _center);
+            _f0.subVectors(_v1$7, _v0$2);
+            _f1.subVectors(_v2$3, _v1$7);
+            _f2.subVectors(_v0$2, _v2$3);
+            let axes = [
+                0, -_f0.z, _f0.y,
+                0, -_f1.z, _f1.y,
+                0, -_f2.z, _f2.y,
+                _f0.z, 0, -_f0.x,
+                _f1.z, 0, -_f1.x,
+                _f2.z, 0, -_f2.x,
+                -_f0.y, _f0.x, 0,
+                -_f1.y, _f1.x, 0,
+                -_f2.y, _f2.x, 0
+            ];
+            if (!satForAxes(axes, _v0$2, _v1$7, _v2$3, _extents)) {
+                return false;
+            }
+            axes = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+            if (!satForAxes(axes, _v0$2, _v1$7, _v2$3, _extents)) {
+                return false;
+            }
+            _triangleNormal.crossVectors(_f0, _f1);
+            axes = [_triangleNormal.x, _triangleNormal.y, _triangleNormal.z];
+            return satForAxes(axes, _v0$2, _v1$7, _v2$3, _extents);
+        }
+        clampPoint(point, target) {
+            return target.copy(point).clamp(this.min, this.max);
+        }
+        distanceToPoint(point) {
+            const clampedPoint = _vector$b.copy(point).clamp(this.min, this.max);
+            return clampedPoint.sub(point).length();
+        }
+        getBoundingSphere(target) {
+            this.getCenter(target.center);
+            target.radius = this.getSize(_vector$b).length() * 0.5;
+            return target;
+        }
+        intersect(box) {
+            this.min.max(box.min);
+            this.max.min(box.max);
+            if (this.isEmpty()) {
+                this.makeEmpty();
+            }
+            return this;
+        }
+        union(box) {
+            this.min.min(box.min);
+            this.max.max(box.max);
+            return this;
+        }
+        applyMatrix4(matrix) {
+            if (this.isEmpty()) {
+                return this;
+            }
+            _points[0].set(this.min.x, this.min.y, this.min.z).applyMatrix4(matrix); // 000
+            _points[1].set(this.min.x, this.min.y, this.max.z).applyMatrix4(matrix); // 001
+            _points[2].set(this.min.x, this.max.y, this.min.z).applyMatrix4(matrix); // 010
+            _points[3].set(this.min.x, this.max.y, this.max.z).applyMatrix4(matrix); // 011
+            _points[4].set(this.max.x, this.min.y, this.min.z).applyMatrix4(matrix); // 100
+            _points[5].set(this.max.x, this.min.y, this.max.z).applyMatrix4(matrix); // 101
+            _points[6].set(this.max.x, this.max.y, this.min.z).applyMatrix4(matrix); // 110
+            _points[7].set(this.max.x, this.max.y, this.max.z).applyMatrix4(matrix); // 111
+            this.setFromPoints(_points);
+            return this;
+        }
+        translate(offset) {
+            this.min.add(offset);
+            this.max.add(offset);
+            return this;
+        }
+        equals(box) {
+            return box.min.equals(this.min) && box.max.equals(this.max);
+        }
+    }
+    const _points = [
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3(),
+        /*@__PURE__*/ new Vector3()
+    ];
+    const _vector$b = /*@__PURE__*/ new Vector3();
+    const _box$3 = /*@__PURE__*/ new Box3();
+    // triangle centered vertices
+    const _v0$2 = /*@__PURE__*/ new Vector3();
+    const _v1$7 = /*@__PURE__*/ new Vector3();
+    const _v2$3 = /*@__PURE__*/ new Vector3();
+    // triangle edge vectors
+    const _f0 = /*@__PURE__*/ new Vector3();
+    const _f1 = /*@__PURE__*/ new Vector3();
+    const _f2 = /*@__PURE__*/ new Vector3();
+    const _center = /*@__PURE__*/ new Vector3();
+    const _extents = /*@__PURE__*/ new Vector3();
+    const _triangleNormal = /*@__PURE__*/ new Vector3();
+    const _testAxis = /*@__PURE__*/ new Vector3();
+    function satForAxes(axes, v0, v1, v2, extents) {
+        for (let i = 0, j = axes.length - 3; i <= j; i += 3) {
+            const _testAxis = new Vector3().fromArray(axes, i);
+            // Project the AABB onto the separating axis
+            const r = extents.x * Math.abs(_testAxis.x) + extents.y * Math.abs(_testAxis.y) + extents.z * Math.abs(_testAxis.z);
+            // Project all 3 vertices of the triangle onto the separating axis
+            const p0 = v0.dot(_testAxis);
+            const p1 = v1.dot(_testAxis);
+            const p2 = v2.dot(_testAxis);
+            // Actual test, basically see if either of the most extreme of the triangle points intersects r
+            if (Math.max(-Math.max(p0, p1, p2), Math.min(p0, p1, p2)) > r) {
+                // Points of the projected triangle are outside the projected half-length of the AABB
+                // The axis is separating, and we can exit
+                return false;
+            }
+        }
+        return true;
+    }
+    const _box$2 = /*@__PURE__*/ new Box3();
+    const _v1$6 = /*@__PURE__*/ new Vector3();
+    const _toFarthestPoint = /*@__PURE__*/ new Vector3();
+    const _toPoint = /*@__PURE__*/ new Vector3();
+    class Sphere {
+        constructor(center = new Vector3(), radius = -1) {
+            this.center = center;
+            this.radius = radius;
+        }
+        set(center, radius) {
+            this.center.copy(center);
+            this.radius = radius;
+            return this;
+        }
+        setFromPoints(points, optionalCenter) {
+            const center = this.center;
+            if (optionalCenter !== undefined) {
+                center.copy(optionalCenter);
+            }
+            else {
+                const box = new Box3();
+                box.setFromPoints(points);
+                box.getCenter(center);
+            }
+            let maxRadiusSq = 0;
+            for (let i = 0, il = points.length; i < il; i++) {
+                maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i]));
+            }
+            this.radius = Math.sqrt(maxRadiusSq);
+            return this;
+        }
+        copy(sphere) {
+            this.center.copy(sphere.center);
+            this.radius = sphere.radius;
+            return this;
+        }
+        isEmpty() {
+            return this.radius < 0;
+        }
+        makeEmpty() {
+            this.center.set(0, 0, 0);
+            this.radius = -1;
+            return this;
+        }
+        containsPoint(point) {
+            return point.distanceToSquared(this.center) <= this.radius * this.radius;
+        }
+        distanceToPoint(point) {
+            return point.distanceTo(this.center) - this.radius;
+        }
+        intersectsSphere(sphere) {
+            const radiusSum = this.radius + sphere.radius;
+            return sphere.center.distanceToSquared(this.center) <= radiusSum * radiusSum;
+        }
+        intersectsBox(box) {
+            return box.intersectsSphere(this);
+        }
+        intersectsPlane(plane) {
+            return Math.abs(plane.distanceToPoint(this.center)) <= this.radius;
+        }
+        clampPoint(point, target) {
+            const deltaLengthSq = this.center.distanceToSquared(point);
+            target.copy(point);
+            if (deltaLengthSq > this.radius * this.radius) {
+                target.sub(this.center).normalize().multiplyScalar(this.radius).add(this.center);
+            }
+            return target;
+        }
+        getBoundingBox(target) {
+            if (this.isEmpty()) {
+                target.makeEmpty();
+                return target;
+            }
+            target.set(this.center, this.center);
+            target.expandByScalar(this.radius);
+            return target;
+        }
+        applyMatrix4(matrix) {
+            this.center.applyMatrix4(matrix);
+            this.radius *= matrix.getMaxScaleOnAxis();
+            return this;
+        }
+        translate(offset) {
+            this.center.add(offset);
+            return this;
+        }
+        expandByPoint(point) {
+            _toPoint.subVectors(point, this.center);
+            const lengthSq = _toPoint.lengthSq();
+            if (lengthSq > this.radius * this.radius) {
+                const length = Math.sqrt(lengthSq);
+                const missingRadiusHalf = (length - this.radius) * 0.5;
+                this.center.add(_toPoint.multiplyScalar(missingRadiusHalf / length));
+                this.radius += missingRadiusHalf;
+            }
+            return this;
+        }
+        union(sphere) {
+            _toFarthestPoint.subVectors(sphere.center, this.center).normalize().multiplyScalar(sphere.radius);
+            this.expandByPoint(_v1$6.copy(sphere.center).add(_toFarthestPoint));
+            this.expandByPoint(_v1$6.copy(sphere.center).sub(_toFarthestPoint));
+            return this;
+        }
+        equals(sphere) {
+            return sphere.center.equals(this.center) && sphere.radius === this.radius;
+        }
+        clone() {
+            return new Sphere().copy(this);
+        }
+    }
+    class Plane {
+        constructor(normal = new Vector3(1, 0, 0), constant = 0) {
+            // normal is assumed to be normalized
+            this.normal = normal;
+            this.constant = constant;
+        }
+        set(normal, constant) {
+            this.normal.copy(normal);
+            this.constant = constant;
+            return this;
+        }
+        setComponents(x, y, z, w) {
+            this.normal.set(x, y, z);
+            this.constant = w;
+            return this;
+        }
+        setFromNormalAndCoplanarPoint(normal, point) {
+            this.normal.copy(normal);
+            this.constant = -point.dot(this.normal);
+            return this;
+        }
+        setFromCoplanarPoints(a, b, c) {
+            const normal = new Vector3().subVectors(c, b).cross(new Vector3().subVectors(a, b)).normalize();
+            this.setFromNormalAndCoplanarPoint(normal, a);
+            return this;
+        }
+        copy(plane) {
+            this.normal.copy(plane.normal);
+            this.constant = plane.constant;
+            return this;
+        }
+        normalize() {
+            // Note: will lead to a divide by zero if the plane is invalid.
+            const inverseNormalLength = 1.0 / this.normal.length();
+            this.normal.multiplyScalar(inverseNormalLength);
+            this.constant *= inverseNormalLength;
+            return this;
+        }
+        negate() {
+            this.constant *= -1;
+            this.normal.negate();
+            return this;
+        }
+        distanceToPoint(point) {
+            return this.normal.dot(point) + this.constant;
+        }
+        distanceToSphere(sphere) {
+            return this.distanceToPoint(sphere.center) - sphere.radius;
+        }
+        projectPoint(point, target) {
+            return target.copy(this.normal).multiplyScalar(-this.distanceToPoint(point)).add(point);
+        }
+        intersectLine(line, target) {
+            const direction = line.delta(new Vector3());
+            const denominator = this.normal.dot(direction);
+            if (denominator === 0) {
+                // Line is coplanar, return origin
+                if (this.distanceToPoint(line.start) === 0) {
+                    return target.copy(line.start);
+                }
+                // Unsure if this is the correct method to handle this case.
+                return null;
+            }
+            const t = -(line.start.dot(this.normal) + this.constant) / denominator;
+            if (t < 0 || t > 1) {
+                return null;
+            }
+            return target.copy(direction).multiplyScalar(t).add(line.start);
+        }
+        intersectsLine(line) {
+            // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
+            const startSign = this.distanceToPoint(line.start);
+            const endSign = this.distanceToPoint(line.end);
+            return (startSign < 0 && endSign > 0) || (endSign < 0 && startSign > 0);
+        }
+        intersectsBox(box) {
+            return box.intersectsPlane(this);
+        }
+        intersectsSphere(sphere) {
+            return sphere.intersectsPlane(this);
+        }
+        coplanarPoint(target) {
+            return target.copy(this.normal).multiplyScalar(-this.constant);
+        }
+        applyMatrix4(matrix, optionalNormalMatrix) {
+            const normalMatrix = optionalNormalMatrix || new Matrix3().getNormalMatrix(matrix);
+            const referencePoint = this.coplanarPoint(new Vector3()).applyMatrix4(matrix);
+            const normal = this.normal.applyMatrix3(normalMatrix).normalize();
+            this.constant = -referencePoint.dot(normal);
+            return this;
+        }
+        translate(offset) {
+            this.constant -= offset.dot(this.normal);
+            return this;
+        }
+        equals(plane) {
+            return plane.normal.equals(this.normal) && plane.constant === this.constant;
+        }
+        clone() {
+            return new Plane().copy(this);
+        }
+    }
+    const _v0$1 = /*@__PURE__*/ new Vector3();
+    const _v1$3 = /*@__PURE__*/ new Vector3();
+    const _v2$2 = /*@__PURE__*/ new Vector3();
+    const _v3$1 = /*@__PURE__*/ new Vector3();
+    const _vab = /*@__PURE__*/ new Vector3();
+    const _vac = /*@__PURE__*/ new Vector3();
+    const _vbc = /*@__PURE__*/ new Vector3();
+    const _vap = /*@__PURE__*/ new Vector3();
+    const _vbp = /*@__PURE__*/ new Vector3();
+    const _vcp = /*@__PURE__*/ new Vector3();
+    class Triangle {
+        constructor(a = new Vector3(), b = new Vector3(), c = new Vector3()) {
+            this.a = a;
+            this.b = b;
+            this.c = c;
+        }
+        static getNormal(a, b, c, target) {
+            target.subVectors(c, b);
+            _v0$1.subVectors(a, b);
+            target.cross(_v0$1);
+            const targetLengthSq = target.lengthSq();
+            if (targetLengthSq > 0) {
+                return target.multiplyScalar(1 / Math.sqrt(targetLengthSq));
+            }
+            return target.set(0, 0, 0);
+        }
+        // static/instance method to calculate barycentric coordinates
+        // based on: http://www.blackpawn.com/texts/pointinpoly/default.html
+        static getBarycoord(point, a, b, c, target) {
+            _v0$1.subVectors(c, a);
+            _v1$3.subVectors(b, a);
+            _v2$2.subVectors(point, a);
+            const dot00 = _v0$1.dot(_v0$1);
+            const dot01 = _v0$1.dot(_v1$3);
+            const dot02 = _v0$1.dot(_v2$2);
+            const dot11 = _v1$3.dot(_v1$3);
+            const dot12 = _v1$3.dot(_v2$2);
+            const denom = (dot00 * dot11 - dot01 * dot01);
+            // collinear or singular triangle
+            if (denom === 0) {
+                // arbitrary location outside of triangle?
+                // not sure if this is the best idea, maybe should be returning undefined
+                return target.set(-2, -1, -1);
+            }
+            const invDenom = 1 / denom;
+            const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+            const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+            // barycentric coordinates must always sum to 1
+            return target.set(1 - u - v, v, u);
+        }
+        static containsPoint(point, a, b, c) {
+            this.getBarycoord(point, a, b, c, _v3$1);
+            return (_v3$1.x >= 0) && (_v3$1.y >= 0) && ((_v3$1.x + _v3$1.y) <= 1);
+        }
+        static getUV(point, p1, p2, p3, uv1, uv2, uv3, target) {
+            this.getBarycoord(point, p1, p2, p3, _v3$1);
+            target.set(0, 0, undefined);
+            target.addScaledVector(uv1, _v3$1.x);
+            target.addScaledVector(uv2, _v3$1.y);
+            target.addScaledVector(uv3, _v3$1.z);
+            return target;
+        }
+        static isFrontFacing(a, b, c, direction) {
+            _v0$1.subVectors(c, b);
+            _v1$3.subVectors(a, b);
+            // strictly front facing
+            return (_v0$1.cross(_v1$3).dot(direction) < 0) ? true : false;
+        }
+        set(a, b, c) {
+            this.a.copy(a);
+            this.b.copy(b);
+            this.c.copy(c);
+            return this;
+        }
+        setFromPointsAndIndices(points, i0, i1, i2) {
+            this.a.copy(points[i0]);
+            this.b.copy(points[i1]);
+            this.c.copy(points[i2]);
+            return this;
+        }
+        setFromAttributeAndIndices(attribute, i0, i1, i2) {
+            this.a.fromBufferAttribute(attribute, i0);
+            this.b.fromBufferAttribute(attribute, i1);
+            this.c.fromBufferAttribute(attribute, i2);
+            return this;
+        }
+        clone() {
+            return new Triangle().copy(this);
+        }
+        copy(triangle) {
+            this.a.copy(triangle.a);
+            this.b.copy(triangle.b);
+            this.c.copy(triangle.c);
+            return this;
+        }
+        getArea() {
+            _v0$1.subVectors(this.c, this.b);
+            _v1$3.subVectors(this.a, this.b);
+            return _v0$1.cross(_v1$3).length() * 0.5;
+        }
+        getMidpoint(target) {
+            return target.addVectors(this.a, this.b).add(this.c).multiplyScalar(1 / 3);
+        }
+        getNormal(target) {
+            return Triangle.getNormal(this.a, this.b, this.c, target);
+        }
+        getPlane(target) {
+            return target.setFromCoplanarPoints(this.a, this.b, this.c);
+        }
+        getBarycoord(point, target) {
+            return Triangle.getBarycoord(point, this.a, this.b, this.c, target);
+        }
+        getUV(point, uv1, uv2, uv3, target) {
+            return Triangle.getUV(point, this.a, this.b, this.c, uv1, uv2, uv3, target);
+        }
+        containsPoint(point) {
+            return Triangle.containsPoint(point, this.a, this.b, this.c);
+        }
+        isFrontFacing(direction) {
+            return Triangle.isFrontFacing(this.a, this.b, this.c, direction);
+        }
+        intersectsBox(box) {
+            return box.intersectsTriangle(this);
+        }
+        closestPointToPoint(p, target) {
+            const a = this.a, b = this.b, c = this.c;
+            let v, w;
+            // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
+            // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
+            // under the accompanying license; see chapter 5.1.5 for detailed explanation.
+            // basically, we're distinguishing which of the voronoi regions of the triangle
+            // the point lies in with the minimum amount of redundant computation.
+            _vab.subVectors(b, a);
+            _vac.subVectors(c, a);
+            _vap.subVectors(p, a);
+            const d1 = _vab.dot(_vap);
+            const d2 = _vac.dot(_vap);
+            if (d1 <= 0 && d2 <= 0) {
+                // vertex region of A; barycentric coords (1, 0, 0)
+                return target.copy(a);
+            }
+            _vbp.subVectors(p, b);
+            const d3 = _vab.dot(_vbp);
+            const d4 = _vac.dot(_vbp);
+            if (d3 >= 0 && d4 <= d3) {
+                // vertex region of B; barycentric coords (0, 1, 0)
+                return target.copy(b);
+            }
+            const vc = d1 * d4 - d3 * d2;
+            if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+                v = d1 / (d1 - d3);
+                // edge region of AB; barycentric coords (1-v, v, 0)
+                return target.copy(a).addScaledVector(_vab, v);
+            }
+            _vcp.subVectors(p, c);
+            const d5 = _vab.dot(_vcp);
+            const d6 = _vac.dot(_vcp);
+            if (d6 >= 0 && d5 <= d6) {
+                // vertex region of C; barycentric coords (0, 0, 1)
+                return target.copy(c);
+            }
+            const vb = d5 * d2 - d1 * d6;
+            if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+                w = d2 / (d2 - d6);
+                // edge region of AC; barycentric coords (1-w, 0, w)
+                return target.copy(a).addScaledVector(_vac, w);
+            }
+            const va = d3 * d6 - d5 * d4;
+            if (va <= 0 && (d4 - d3) >= 0 && (d5 - d6) >= 0) {
+                _vbc.subVectors(c, b);
+                w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+                // edge region of BC; barycentric coords (0, 1-w, w)
+                return target.copy(b).addScaledVector(_vbc, w); // edge region of BC
+            }
+            // face region
+            const denom = 1 / (va + vb + vc);
+            // u = va * denom
+            v = vb * denom;
+            w = vc * denom;
+            return target.copy(a).addScaledVector(_vab, v).addScaledVector(_vac, w);
+        }
+        equals(triangle) {
+            return triangle.a.equals(this.a) && triangle.b.equals(this.b) && triangle.c.equals(this.c);
+        }
+    }
     //#endregion
     const _vector$9 = /*@__PURE__*/ new Vector3(0, 0, 0);
     const _vector2$1 = /*@__PURE__*/ new Vector2();
     class BufferAttribute {
-        constructor(array, itemSize, normalized) {
+        constructor(array, itemSize, normalized = true) {
             this.name = '';
             if (Array.isArray(array)) {
                 throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.');
@@ -2027,436 +2648,103 @@ function workerFunction() {
             return data;
         }
     }
-    // class BufferGeometry extends EventDispatcher {
-    //     uuid: string;
-    //     name: string;
-    //     type: string;
-    //     index: BufferAttribute | null;
-    //     attributes: { [name: string]: BufferAttribute };
-    //     morphAttributes: { [name: string]: BufferAttribute[] };
-    //     morphTargetsRelative: boolean;
-    //     groups: { start: number; count: number; materialIndex: number }[];
-    //     boundingBox: Box3 | null;
-    //     boundingSphere: Sphere | null;
-    //     drawRange: { start: number; count: number };
-    //     userData: { [key: string]: any };
-    //     constructor() {
-    //         super();
-    //         Object.defineProperty(this, 'id', { value: _id++ });
-    //         this.uuid = generateUUID();
-    //         this.name = '';
-    //         this.type = 'BufferGeometry';
-    //         this.index = null;
-    //         this.attributes = {};
-    //         this.morphAttributes = {};
-    //         this.morphTargetsRelative = false;
-    //         this.groups = [];
-    //         this.boundingBox = null;
-    //         this.boundingSphere = null;
-    //         this.drawRange = { start: 0, count: Infinity };
-    //         this.userData = {};
-    //     }
-    //     getIndex(): BufferAttribute | null {
-    //         return this.index;
-    //     }
-    //     setIndex(index: BufferAttribute | number[]): this {
-    //         if (Array.isArray(index)) {
-    //             this.index = new (arrayMax(index) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute)(
-    //                 index,
-    //                 1
-    //             );
-    //         } else {
-    //             this.index = index;
-    //         }
-    //         return this;
-    //     }
-    //     getAttribute(name: string): BufferAttribute | undefined {
-    //         return this.attributes[name];
-    //     }
-    //     setAttribute(name: string, attribute: BufferAttribute): this {
-    //         this.attributes[name] = attribute;
-    //         return this;
-    //     }
-    //     deleteAttribute(name: string): this {
-    //         delete this.attributes[name];
-    //         return this;
-    //     }
-    //     hasAttribute(name: string): boolean {
-    //         return this.attributes[name] !== undefined;
-    //     }
-    //     addGroup(start: number, count: number, materialIndex: number = 0): void {
-    //         this.groups.push({
-    //             start,
-    //             count,
-    //             materialIndex,
-    //         });
-    //     }
-    //     clearGroups(): void {
-    //         this.groups = [];
-    //     }
-    //     setDrawRange(start: number, count: number): void {
-    //         this.drawRange.start = start;
-    //         this.drawRange.count = count;
-    //     }
-    //     applyMatrix4(matrix: Matrix4): this {
-    //         const position = this.attributes.position;
-    //         if (position !== undefined) {
-    //             position.applyMatrix4(matrix);
-    //             position.needsUpdate = true;
-    //         }
-    //         const normal = this.attributes.normal;
-    //         if (normal !== undefined) {
-    //             const normalMatrix = new Matrix3().getNormalMatrix(matrix);
-    //             normal.applyNormalMatrix(normalMatrix);
-    //             normal.needsUpdate = true;
-    //         }
-    //         const tangent = this.attributes.tangent;
-    //         if (tangent !== undefined) {
-    //             tangent.transformDirection(matrix);
-    //             tangent.needsUpdate = true;
-    //         }
-    //         if (this.boundingBox !== null) {
-    //             this.computeBoundingBox();
-    //         }
-    //         if (this.boundingSphere !== null) {
-    //             this.computeBoundingSphere();
-    //         }
-    //         return this;
-    //     }
-    //     applyQuaternion(q: Quaternion): this {
-    //         _m1.makeRotationFromQuaternion(q);
-    //         this.applyMatrix4(_m1);
-    //         return this;
-    //     }
-    //     rotateX(angle: number): this {
-    //         _m1.makeRotationX(angle);
-    //         this.applyMatrix4(_m1);
-    //         return this;
-    //     }
-    //     rotateY(angle: number): this {
-    //         _m1.makeRotationY(angle);
-    //         this.applyMatrix4(_m1);
-    //         return this;
-    //     }
-    //     rotateZ(angle: number): this {
-    //         _m1.makeRotationZ(angle);
-    //         this.applyMatrix4(_m1);
-    //         return this;
-    //     }
-    //     translate(x: number, y: number, z: number): this {
-    //         _m1.makeTranslation(x, y, z);
-    //         this.applyMatrix4(_m1);
-    //         return this;
-    //     }
-    //     scale(x: number, y: number, z: number): this {
-    //         _m1.makeScale(x, y, z);
-    //         this.applyMatrix4(_m1);
-    //         return this;
-    //     }
-    //     lookAt(vector: Vector3): this {
-    //         _obj.lookAt(vector);
-    //         _obj.updateMatrix();
-    //         this.applyMatrix4(_obj.matrix);
-    //         return this;
-    //     }
-    //     center(): this {
-    //         this.computeBoundingBox();
-    //         this.boundingBox.getCenter(_offset).negate();
-    //         this.translate(_offset.x, _offset.y, _offset.z);
-    //         return this;
-    //     }
-    //     setFromPoints(points: Vector3[]): this {
-    //         const position: number[] = [];
-    //         for (let i = 0, l = points.length; i < l; i++) {
-    //             const point = points[i];
-    //             position.push(point.x, point.y, point.z || 0);
-    //         }
-    //         this.setAttribute('position', new Float32BufferAttribute(position, 3));
-    //         return this;
-    //     }
-    //     computeBoundingBox(): void {
-    //         if (this.boundingBox === null) {
-    //             this.boundingBox = new Box3();
-    //         }
-    //         const position = this.attributes.position;
-    //         const morphAttributesPosition = this.morphAttributes.position;
-    //         if (position && position.isGLBufferAttribute) {
-    //             console.error(
-    //                 'THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',
-    //                 this
-    //             );
-    //             this.boundingBox.set(
-    //                 new Vector3(-Infinity, -Infinity, -Infinity),
-    //                 new Vector3(+Infinity, +Infinity, +Infinity)
-    //             );
-    //             return;
-    //         }
-    //         if (position !== undefined) {
-    //             this.boundingBox.setFromBufferAttribute(position);
-    //             // process morph attributes if present
-    //             if (morphAttributesPosition) {
-    //                 for (let i = 0, il = morphAttributesPosition.length; i < il; i++) {
-    //                     const morphAttribute = morphAttributesPosition[i];
-    //                     _box.fromBufferAttribute(morphAttribute);
-    //                     _box.min.add(this.boundingBox.min);
-    //                     _box.max.add(this.boundingBox.max);
-    //                     this.boundingBox.union(_box);
-    //                 }
-    //             }
-    //         }
-    //     }
-    //     computeBoundingSphere(): void {
-    //         if (this.boundingSphere === null) {
-    //             this.boundingSphere = new Sphere();
-    //         }
-    //         const position = this.attributes.position;
-    //         const morphAttributesPosition = this.morphAttributes.position;
-    //         if (position && position.isGLBufferAttribute) {
-    //             console.error(
-    //                 'THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',
-    //                 this
-    //             );
-    //             this.boundingSphere.set(
-    //                 new Vector3(),
-    //                 Infinity
-    //             );
-    //             return;
-    //         }
-    //         if (position) {
-    //             const center = this.boundingSphere.center;
-    //             this.boundingSphere.radius = position.isInterleavedBufferAttribute
-    //                 ? position.data.stride <= 0 ? 0 : position.data.stride / 4
-    //                 : 0;
-    //             // process morph attributes if present
-    //             if (morphAttributesPosition) {
-    //                 for (let i = 0, il = morphAttributesPosition.length; i < il; i++) {
-    //                     const morphAttribute = morphAttributesPosition[i];
-    //                     const morphRadius = 0;
-    //                     if (morphAttribute.isInterleavedBufferAttribute) {
-    //                         console.error(
-    //                             'THREE.BufferGeometry.computeBoundingSphere(): morphAttribute isInterleavedBufferAttribute is not supported. Please use regular BufferAttribute.'
-    //                         );
-    //                         continue;
-    //                     }
-    //                     for (let i = 0, il = morphAttribute.count; i < il; i++) {
-    //                         _v1.x = morphAttribute.getX(i);
-    //                         _v1.y = morphAttribute.getY(i);
-    //                         _v1.z = morphAttribute.getZ(i);
-    //                         morphRadius = Math.max(morphRadius, center.distanceToSquared(_v1));
-    //                     }
-    //                     this.boundingSphere.radius = Math.max(this.boundingSphere.radius, Math.sqrt(morphRadius));
-    //                 }
-    //             }
-    //             // process regular attributes
-    //             for (let i = 0, il = position.count; i < il; i++) {
-    //                 _v1.x = position.getX(i);
-    //                 _v1.y = position.getY(i);
-    //                 _v1.z = position.getZ(i);
-    //                 this.boundingSphere.radius = Math.max(this.boundingSphere.radius, center.distanceToSquared(_v1));
-    //             }
-    //             this.boundingSphere.radius = Math.sqrt(this.boundingSphere.radius);
-    //         }
-    //     }
-    //     computeTangents(): this {
-    //         console.warn(
-    //             'THREE.BufferGeometry: .computeTangents() has been removed. Please use the TangentSpaceNormalMap shader or THREE.TangentSpaceUtils.computeTangents() instead.'
-    //         );
-    //         return this;
-    //     }
-    //     computeVertexNormals(): this {
-    //         console.error(
-    //             'THREE.BufferGeometry: .computeVertexNormals() has been removed. Use THREE.BufferGeometryUtils.computeNormals() instead.'
-    //         );
-    //         return this;
-    //     }
-    //     computeFaceNormals(): this {
-    //         const cb = new Vector3(), ab = new Vector3();
-    //         if (this.index !== null) {
-    //             // indexed BufferGeometry
-    //             const indices = this.index.array;
-    //             const positions = this.attributes.position.array;
-    //             const normals = this.attributes.normal !== undefined ? this.attributes.normal.array : null;
-    //             for (let i = 0, il = indices.length; i < il; i += 3) {
-    //                 const a = indices[i + 0];
-    //                 const b = indices[i + 1];
-    //                 const c = indices[i + 2];
-    //                 if (normals !== null) {
-    //                     const x = normals[a * 3 + 0] + normals[b * 3 + 0] + normals[c * 3 + 0];
-    //                     const y = normals[a * 3 + 1] + normals[b * 3 + 1] + normals[c * 3 + 1];
-    //                     const z = normals[a * 3 + 2] + normals[b * 3 + 2] + normals[c * 3 + 2];
-    //                     _cb.set(x, y, z).normalize();
-    //                 } else {
-    //                     // flat normals
-    //                     const x = positions[a * 3 + 0] - positions[b * 3 + 0];
-    //                     const y = positions[a * 3 + 1] - positions[b * 3 + 1];
-    //                     const z = positions[a * 3 + 2] - positions[b * 3 + 2];
-    //                     _cb.set(x, y, z).normalize();
-    //                 }
-    //                 _ab.set(positions[a * 3 + 0] - positions[c * 3 + 0], positions[a * 3 + 1] - positions[c * 3 + 1], positions[a * 3 + 2] - positions[c * 3 + 2]);
-    //                 _cb.cross(_ab).normalize();
-    //                 normals[a * 3 + 0] += _cb.x;
-    //                 normals[a * 3 + 1] += _cb.y;
-    //                 normals[a * 3 + 2] += _cb.z;
-    //                 normals[b * 3 + 0] += _cb.x;
-    //                 normals[b * 3 + 1] += _cb.y;
-    //                 normals[b * 3 + 2] += _cb.z;
-    //                 normals[c * 3 + 0] += _cb.x;
-    //                 normals[c * 3 + 1] += _cb.y;
-    //                 normals[c * 3 + 2] += _cb.z;
-    //             }
-    //             this.normalizeNormals();
-    //             this.attributes.normal.needsUpdate = true;
-    //         } else {
-    //             // non-indexed BufferGeometry
-    //             const positions = this.attributes.position.array;
-    //             const normals = this.attributes.normal !== undefined ? this.attributes.normal.array : null;
-    //             for (let i = 0, il = positions.length; i < il; i += 9) {
-    //                 // flat normals
-    //                 const x = positions[i + 0] - positions[i + 3];
-    //                 const y = positions[i + 1] - positions[i + 4];
-    //                 const z = positions[i + 2] - positions[i + 5];
-    //                 _cb.set(x, y, z).normalize();
-    //                 const a = x;
-    //                 const b = y;
-    //                 const c = z;
-    //                 x = positions[i + 0] - positions[i + 6];
-    //                 y = positions[i + 1] - positions[i + 7];
-    //                 z = positions[i + 2] - positions[i + 8];
-    //                 _ab.set(x, y, z).normalize();
-    //                 x = positions[i + 3] - positions[i + 6];
-    //                 y = positions[i + 4] - positions[i + 7];
-    //                 z = positions[i + 5] - positions[i + 8];
-    //                 _ab.set(x, y, z).normalize();
-    //                 _cb.cross(_ab).normalize();
-    //                 if (normals !== null) {
-    //                     normals[i + 0] = normals[i + 3] = normals[i + 6] = _cb.x;
-    //                     normals[i + 1] = normals[i + 4] = normals[i + 7] = _cb.y;
-    //                     normals[i + 2] = normals[i + 5] = normals[i + 8] = _cb.z;
-    //                 }
-    //             }
-    //             this.normalizeNormals();
-    //             if (normals !== null) this.attributes.normal.needsUpdate = true;
-    //         }
-    //         return this;
-    //     }
-    //     computeMorphNormals(): this {
-    //         const normal = new Vector3();
-    //         return function computeMorphNormals() {
-    //             const morphNormals = this.morphAttributes.normal;
-    //             const normalAttribute = this.attributes.normal;
-    //             if (morphNormals && normalAttribute) {
-    //                 const numMorphTargets = morphNormals.length;
-    //                 const numNormals = normalAttribute.count;
-    //                 for (let i = 0; i < numNormals; i++) {
-    //                     normal.set(0, 0, 0);
-    //                     for (let j = 0; j < numMorphTargets; j++) {
-    //                         const morphAttribute = morphNormals[j];
-    //                         // computing the tangent space for true normals is expensive
-    //                         // don't use for morphNormals if normal is null
-    //                         if (normalAttribute) {
-    //                             _normal.fromBufferAttribute(normalAttribute, i);
-    //                             _morphedNormal.fromBufferAttribute(morphAttribute, i);
-    //                             // compute normals
-    //                             _normal.applyQuaternion(this._rotationMatrix);
-    //                             _morphedNormal.applyQuaternion(this._rotationMatrix);
-    //                             // compute morph normal
-    //                             _morphedNormal.sub(_normal).multiplyScalar(this.morphTargetInfluences[j]);
-    //                             normal.add(_morphedNormal);
-    //                         }
-    //                     }
-    //                     normal.normalize();
-    //                     normalAttribute.setXYZ(i, normal.x, normal.y, normal.z);
-    //                 }
-    //                 normalAttribute.needsUpdate = true;
-    //             }
-    //         };
-    //     }
-    //     computeMorphTangents(): this {
-    //         const normal = new Vector3();
-    //         return function computeMorphTangents() {
-    //             const morphNormals = this.morphAttributes.normal;
-    //             const morphTangents = this.morphAttributes.tangent;
-    //             const normalAttribute = this.attributes.normal;
-    //             const tangentAttribute = this.attributes.tangent;
-    //             if (morphTangents && morphNormals && normalAttribute && tangentAttribute) {
-    //                 const numMorphTargets = morphNormals.length;
-    //                 const numTangents = tangentAttribute.count;
-    //                 for (let i = 0; i < numTangents; i++) {
-    //                     normal.set(0, 0, 0);
-    //                     for (let j = 0; j < numMorphTargets; j++) {
-    //                         const morphAttribute = morphNormals[j];
-    //                         const morphTangent = morphTangents[j];
-    //                         // computing the tangent space for true normals is expensive
-    //                         // don't use for morphNormals if normal is null
-    //                         if (normalAttribute) {
-    //                             _normal.fromBufferAttribute(normalAttribute, i);
-    //                             _morphedNormal.fromBufferAttribute(morphAttribute, i);
-    //                             // compute normals
-    //                             _normal.applyQuaternion(this._rotationMatrix);
-    //                             _morphedNormal.applyQuaternion(this._rotationMatrix);
-    //                             // compute morph normal
-    //                             _morphedNormal.sub(_normal).multiplyScalar(this.morphTargetInfluences[j]);
-    //                             normal.add(_morphedNormal);
-    //                             // compute morph tangent
-    //                             if (morphTangent) {
-    //                                 _tangent.fromBufferAttribute(morphTangent, i);
-    //                                 _morphedTangent.fromBufferAttribute(morphTangent, i);
-    //                                 _tangent.applyQuaternion(this._rotationMatrix);
-    //                                 _morphedTangent.applyQuaternion(this._rotationMatrix);
-    //                                 _morphedTangent.sub(_tangent).multiplyScalar(this.morphTargetInfluences[j]);
-    //                                 normal.add(_morphedTangent);
-    //                             }
-    //                         }
-    //                     }
-    //                     normal.normalize();
-    //                     tangentAttribute.setXYZ(i, normal.x, normal.y, normal.z);
-    //                 }
-    //                 tangentAttribute.needsUpdate = true;
-    //             }
-    //         };
-    //     }
-    //     clearGroups(): void {
-    //         this.groups.length = 0;
-    //         this.drawRange.start = 0;
-    //         this.drawRange.count = Infinity;
-    //     }
-    //     setDrawRange(start: number, count: number): void {
-    //         this.drawRange.start = start;
-    //         this.drawRange.count = count;
-    //     }
-    //     updateFromObject(object: Object3D): void {
-    //         if (object.geometry === this) {
-    //             console.error(
-    //                 'THREE.BufferGeometry.updateFromObject(): The object and its geometry are already linked.'
-    //             );
-    //             return;
-    //         }
-    //         const geometry2 = object.geometry;
-    //         if (object.isPoints || object.isLine) {
-    //             const attributes = this.attributes;
-    //             if (geometry2.isBufferGeometry) {
-    //                 attributes.position.updateRange = { offset: 0, count: geometry2.attributes.position.count };
-    //                 const array = geometry2.attributes.position.array;
-    //                 for (let i = 0; i < array.length; i++) {
-    //                     attributes.position.array[i] = array[i];
-    //                 }
-    //                 attributes.position.needsUpdate = true;
-    //             }
-    //         } else if (object.isMesh) {
-    //             const newGeometry = geometry2.clone();
-    //             this.fromGeometry(newGeometry);
-    //         }
-    //     }
-    //     /**
-    //      * @deprecated Use {@link BufferGeometry#toJSON .toJSON()} instead.
-    //      */
-    //     toJSON(): any {
-    //         return this.toBufferGeometry().toJSON();
-    //     }
-    //     dispose(): void {
-    //         this.dispatchEvent({ type: 'dispose' });
-    //     }
-    // }
+    let _id = 0;
+    const _vector$8 = /*@__PURE__*/ new Vector3();
+    class BufferGeometry extends EventDispatcher {
+        constructor() {
+            super();
+            Object.defineProperty(this, 'id', { value: _id++ });
+            this.uuid = generateUUID();
+            this.name = '';
+            this.type = 'BufferGeometry';
+            this.index = null;
+            this.attributes = {};
+            this.morphAttributes = {};
+            this.morphTargetsRelative = false;
+            this.groups = [];
+            this.boundingBox = null;
+            this.boundingSphere = null;
+            this.drawRange = { start: 0, count: Infinity };
+            this.userData = {};
+        }
+        getIndex() {
+            return this.index;
+        }
+        setAttribute(name, attribute) {
+            this.attributes[name] = attribute;
+            return this;
+        }
+        getAttribute(name) {
+            return this.attributes[name];
+        }
+        computeVertexNormals() {
+            const index = this.index;
+            const positionAttribute = this.getAttribute('position');
+            if (positionAttribute !== undefined) {
+                let normalAttribute = this.getAttribute('normal');
+                if (normalAttribute === undefined) {
+                    normalAttribute = new BufferAttribute(new Float32Array(positionAttribute.count * 3), 3);
+                    this.setAttribute('normal', normalAttribute);
+                }
+                else {
+                    // reset existing normals to zero
+                    for (let i = 0, il = normalAttribute.count; i < il; i++) {
+                        normalAttribute.setXYZ(i, 0, 0, 0);
+                    }
+                }
+                const pA = new Vector3(), pB = new Vector3(), pC = new Vector3();
+                const nA = new Vector3(), nB = new Vector3(), nC = new Vector3();
+                const cb = new Vector3(), ab = new Vector3();
+                // indexed elements
+                if (index) {
+                    for (let i = 0, il = index.count; i < il; i += 3) {
+                        const vA = index.getX(i + 0);
+                        const vB = index.getX(i + 1);
+                        const vC = index.getX(i + 2);
+                        pA.fromBufferAttribute(positionAttribute, vA);
+                        pB.fromBufferAttribute(positionAttribute, vB);
+                        pC.fromBufferAttribute(positionAttribute, vC);
+                        cb.subVectors(pC, pB);
+                        ab.subVectors(pA, pB);
+                        cb.cross(ab);
+                        nA.fromBufferAttribute(normalAttribute, vA);
+                        nB.fromBufferAttribute(normalAttribute, vB);
+                        nC.fromBufferAttribute(normalAttribute, vC);
+                        nA.add(cb);
+                        nB.add(cb);
+                        nC.add(cb);
+                        normalAttribute.setXYZ(vA, nA.x, nA.y, nA.z);
+                        normalAttribute.setXYZ(vB, nB.x, nB.y, nB.z);
+                        normalAttribute.setXYZ(vC, nC.x, nC.y, nC.z);
+                    }
+                }
+                else {
+                    // non-indexed elements (unconnected triangle soup)
+                    for (let i = 0, il = positionAttribute.count; i < il; i += 3) {
+                        pA.fromBufferAttribute(positionAttribute, i + 0);
+                        pB.fromBufferAttribute(positionAttribute, i + 1);
+                        pC.fromBufferAttribute(positionAttribute, i + 2);
+                        cb.subVectors(pC, pB);
+                        ab.subVectors(pA, pB);
+                        cb.cross(ab);
+                        normalAttribute.setXYZ(i + 0, cb.x, cb.y, cb.z);
+                        normalAttribute.setXYZ(i + 1, cb.x, cb.y, cb.z);
+                        normalAttribute.setXYZ(i + 2, cb.x, cb.y, cb.z);
+                    }
+                }
+                this.normalizeNormals();
+                normalAttribute.needsUpdate = true;
+            }
+        }
+        normalizeNormals() {
+            const normals = this.attributes.normal;
+            for (let i = 0, il = normals.count; i < il; i++) {
+                _vector$8.fromBufferAttribute(normals, i);
+                _vector$8.normalize();
+                normals.setXYZ(i, _vector$8.x, _vector$8.y, _vector$8.z);
+            }
+        }
+    }
     //#endregion
 }
 exports.workerCode = workerFunction;