viral-viewer-2 2.2.0 → 2.2.2

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

@@ -105,6 +105,627 @@ function workerFunction() {
                 break;
         }
     }, 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 = {};
+        }
+        addEventListener(type, listener) {
+            if (this._listeners[type] === undefined)
+                this._listeners[type] = [];
+            const listeners = this._listeners[type];
+            if (listeners.indexOf(listener) === -1) {
+                listeners.push(listener);
+            }
+        }
+        hasEventListener(type, listener) {
+            if (this._listeners[type] === undefined)
+                return false;
+            const listeners = this._listeners[type];
+            return listeners !== undefined && listeners.indexOf(listener) !== -1;
+        }
+        removeEventListener(type, listener) {
+            if (this._listeners[type] === undefined)
+                return;
+            const listeners = this._listeners[type];
+            if (listeners !== undefined) {
+                const index = listeners.indexOf(listener);
+                if (index !== -1) {
+                    listeners.splice(index, 1);
+                }
+            }
+        }
+        dispatchEvent(event) {
+            if (this._listeners[event.type] === undefined)
+                return;
+            const listeners = this._listeners[event.type];
+            if (listeners !== undefined) {
+                event.target = this;
+                // Make a copy, in case listeners are removed while iterating.
+                const array = listeners.slice(0);
+                for (let i = 0, l = array.length; i < l; i++) {
+                    array[i].call(this, event);
+                }
+                event.target = undefined;
+            }
+        }
+    }
+    const _lut = [];
+    for (let i = 0; i < 256; i++) {
+        _lut[i] = (i < 16 ? '0' : '') + (i).toString(16);
+    }
+    const DEG2RAD = Math.PI / 180;
+    const RAD2DEG = 180 / Math.PI;
+    const generateUUID = () => {
+        const d0 = Math.random() * 0xffffffff | 0;
+        const d1 = Math.random() * 0xffffffff | 0;
+        const d2 = Math.random() * 0xffffffff | 0;
+        const d3 = Math.random() * 0xffffffff | 0;
+        const uuid = _lut[d0 & 0xff] + _lut[d0 >> 8 & 0xff] + _lut[d0 >> 16 & 0xff] + _lut[d0 >> 24 & 0xff] + '-' +
+            _lut[d1 & 0xff] + _lut[d1 >> 8 & 0xff] + '-' + _lut[d1 >> 16 & 0x0f | 0x40] + _lut[d1 >> 24 & 0xff] + '-' +
+            _lut[d2 & 0x3f | 0x80] + _lut[d2 >> 8 & 0xff] + '-' + _lut[d2 >> 16 & 0xff] + _lut[d2 >> 24 & 0xff] +
+            _lut[d3 & 0xff] + _lut[d3 >> 8 & 0xff] + _lut[d3 >> 16 & 0xff] + _lut[d3 >> 24 & 0xff];
+        // .toUpperCase() here flattens concatenated strings to save heap memory space.
+        return uuid.toUpperCase();
+    };
+    function clamp(value, min, max) {
+        return Math.max(min, Math.min(max, value));
+    }
+    // Compute euclidean modulo of n % m
+    // https://en.wikipedia.org/wiki/Modulo_operation
+    function euclideanModulo(n, m) {
+        return ((n % m) + m) % m;
+    }
+    // https://en.wikipedia.org/wiki/Linear_interpolation
+    function lerp(x, y, t) {
+        return (1 - t) * x + t * y;
+    }
+    function isPowerOfTwo(value) {
+        return (value & (value - 1)) === 0 && value !== 0;
+    }
+    function floorPowerOfTwo(value) {
+        return Math.pow(2, Math.floor(Math.log(value) / Math.LN2));
+    }
+    //#region Color
+    const _colorKeywords = {
+        'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,
+        'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,
+        'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,
+        'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,
+        'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,
+        'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,
+        'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,
+        'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,
+        'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,
+        'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,
+        'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,
+        'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,
+        'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,
+        'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,
+        'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,
+        'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,
+        'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,
+        'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,
+        'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,
+        'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,
+        'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,
+        'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,
+        'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,
+        'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32
+    };
+    const _hslA = { h: 0, s: 0, l: 0 };
+    const _hslB = { h: 0, s: 0, l: 0 };
+    function hue2rgb(p, q, t) {
+        if (t < 0)
+            t += 1;
+        if (t > 1)
+            t -= 1;
+        if (t < 1 / 6)
+            return p + (q - p) * 6 * t;
+        if (t < 1 / 2)
+            return q;
+        if (t < 2 / 3)
+            return p + (q - p) * 6 * (2 / 3 - t);
+        return p;
+    }
+    function SRGBToLinear(c) {
+        return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+    }
+    function LinearToSRGB(c) {
+        return c < 0.0031308 ? c * 12.92 : 1.055 * Math.pow(c, 0.41666) - 0.055;
+    }
+    class Color {
+        constructor(r, g, b) {
+            this.r = 0;
+            this.g = 0;
+            this.b = 0;
+            if (g === undefined && b === undefined) {
+                // r is THREE.Color, hex, or string
+                return this.set(r);
+            }
+            return this.setRGB(r, g, b);
+        }
+        set(value) {
+            if (value && value.isColor) {
+                this.copy(value);
+            }
+            else if (typeof value === 'number') {
+                this.setHex(value);
+            }
+            else if (typeof value === 'string') {
+                this.setStyle(value);
+            }
+            return this;
+        }
+        setScalar(scalar) {
+            this.r = scalar;
+            this.g = scalar;
+            this.b = scalar;
+            return this;
+        }
+        setHex(hex) {
+            hex = Math.floor(hex);
+            this.r = ((hex >> 16) & 255) / 255;
+            this.g = ((hex >> 8) & 255) / 255;
+            this.b = (hex & 255) / 255;
+            return this;
+        }
+        setRGB(r, g, b) {
+            this.r = r;
+            this.g = g;
+            this.b = b;
+            return this;
+        }
+        setHSL(h, s, l) {
+            // h, s, l ranges are in 0.0 - 1.0
+            h = euclideanModulo(h, 1);
+            s = clamp(s, 0, 1);
+            l = clamp(l, 0, 1);
+            if (s === 0) {
+                this.r = this.g = this.b = l;
+            }
+            else {
+                const p = l <= 0.5 ? l * (1 + s) : l + s - (l * s);
+                const q = 2 * l - p;
+                this.r = hue2rgb(q, p, h + 1 / 3);
+                this.g = hue2rgb(q, p, h);
+                this.b = hue2rgb(q, p, h - 1 / 3);
+            }
+            return this;
+        }
+        setStyle(style) {
+            function handleAlpha(string) {
+                if (string === undefined)
+                    return;
+                if (parseFloat(string) < 1) {
+                    console.warn('THREE.Color: Alpha component of ' + style + ' will be ignored.');
+                }
+            }
+            let m;
+            if ((m = /^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(style))) {
+                // rgb / hsl
+                let color;
+                const name = m[1];
+                const components = m[2];
+                switch (name) {
+                    case 'rgb':
+                    case 'rgba':
+                        if ((color = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components))) {
+                            // rgb(255,0,0) rgba(255,0,0,0.5)
+                            this.r = Math.min(255, parseInt(color[1], 10)) / 255;
+                            this.g = Math.min(255, parseInt(color[2], 10)) / 255;
+                            this.b = Math.min(255, parseInt(color[3], 10)) / 255;
+                            handleAlpha(color[4]);
+                            return this;
+                        }
+                        if ((color = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components))) {
+                            // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
+                            this.r = Math.min(100, parseInt(color[1], 10)) / 100;
+                            this.g = Math.min(100, parseInt(color[2], 10)) / 100;
+                            this.b = Math.min(100, parseInt(color[3], 10)) / 100;
+                            handleAlpha(color[4]);
+                            return this;
+                        }
+                        break;
+                    case 'hsl':
+                    case 'hsla':
+                        if ((color = /^\s*(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components))) {
+                            // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
+                            const h = parseFloat(color[1]) / 360;
+                            const s = parseInt(color[2], 10) / 100;
+                            const l = parseInt(color[3], 10) / 100;
+                            handleAlpha(color[4]);
+                            return this.setHSL(h, s, l);
+                        }
+                        break;
+                }
+            }
+            else if ((m = /^\#([A-Fa-f\d]+)$/.exec(style))) {
+                // hex color
+                const hex = m[1];
+                const size = hex.length;
+                if (size === 3) {
+                    // #ff0
+                    this.r = parseInt(hex.charAt(0) + hex.charAt(0), 16) / 255;
+                    this.g = parseInt(hex.charAt(1) + hex.charAt(1), 16) / 255;
+                    this.b = parseInt(hex.charAt(2) + hex.charAt(2), 16) / 255;
+                    return this;
+                }
+                else if (size === 6) {
+                    // #ff0000
+                    this.r = parseInt(hex.charAt(0) + hex.charAt(1), 16) / 255;
+                    this.g = parseInt(hex.charAt(2) + hex.charAt(3), 16) / 255;
+                    this.b = parseInt(hex.charAt(4) + hex.charAt(5), 16) / 255;
+                    return this;
+                }
+            }
+            if (style && style.length > 0) {
+                return this.setColorName(style);
+            }
+            return this;
+        }
+        setColorName(style) {
+            // color keywords
+            let key = style.toLowerCase();
+            const hex = _colorKeywords[key];
+            if (hex !== undefined) {
+                // red
+                this.setHex(hex);
+            }
+            else {
+                // unknown color
+                console.warn('THREE.Color: Unknown color ' + style);
+            }
+            return this;
+        }
+        clone() {
+            return new Color(this.r, this.g, this.b);
+        }
+        copy(color) {
+            this.r = color.r;
+            this.g = color.g;
+            this.b = color.b;
+            return this;
+        }
+        copyGammaToLinear(color, gammaFactor = 2.0) {
+            this.r = Math.pow(color.r, gammaFactor);
+            this.g = Math.pow(color.g, gammaFactor);
+            this.b = Math.pow(color.b, gammaFactor);
+            return this;
+        }
+        copyLinearToGamma(color, gammaFactor = 2.0) {
+            const safeInverse = gammaFactor > 0 ? 1.0 / gammaFactor : 1.0;
+            this.r = Math.pow(color.r, safeInverse);
+            this.g = Math.pow(color.g, safeInverse);
+            this.b = Math.pow(color.b, safeInverse);
+            return this;
+        }
+        convertGammaToLinear(gammaFactor) {
+            this.copyGammaToLinear(this, gammaFactor);
+            return this;
+        }
+        convertLinearToGamma(gammaFactor) {
+            this.copyLinearToGamma(this, gammaFactor);
+            return this;
+        }
+        copySRGBToLinear(color) {
+            this.r = SRGBToLinear(color.r);
+            this.g = SRGBToLinear(color.g);
+            this.b = SRGBToLinear(color.b);
+            return this;
+        }
+        copyLinearToSRGB(color) {
+            this.r = LinearToSRGB(color.r);
+            this.g = LinearToSRGB(color.g);
+            this.b = LinearToSRGB(color.b);
+            return this;
+        }
+        convertSRGBToLinear() {
+            this.copySRGBToLinear(this);
+            return this;
+        }
+        convertLinearToSRGB() {
+            this.copyLinearToSRGB(this);
+            return this;
+        }
+        getHex() {
+            return (this.r * 255) << 16 ^ (this.g * 255) << 8 ^ (this.b * 255) << 0;
+        }
+        getHexString() {
+            return ('000000' + this.getHex().toString(16)).slice(-6);
+        }
+        getHSL(target) {
+            const r = this.r, g = this.g, b = this.b;
+            const max = Math.max(r, g, b);
+            const min = Math.min(r, g, b);
+            let hue = 0, saturation = 0;
+            const lightness = (min + max) / 2.0;
+            if (min === max) {
+                hue = 0;
+                saturation = 0;
+            }
+            else {
+                const delta = max - min;
+                saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min);
+                switch (max) {
+                    case r:
+                        hue = (g - b) / delta + (g < b ? 6 : 0);
+                        break;
+                    case g:
+                        hue = (b - r) / delta + 2;
+                        break;
+                    case b:
+                        hue = (r - g) / delta + 4;
+                        break;
+                }
+                hue /= 6;
+            }
+            target.h = hue;
+            target.s = saturation;
+            target.l = lightness;
+            return target;
+        }
+        getStyle() {
+            return 'rgb(' + (this.r * 255) + ',' + (this.g * 255) + ',' + (this.b * 255) + ')';
+        }
+        offsetHSL(h, s, l) {
+            this.getHSL(_hslA);
+            _hslA.h += h;
+            _hslA.s += s;
+            _hslA.l += l;
+            this.setHSL(_hslA.h, _hslA.s, _hslA.l);
+            return this;
+        }
+        add(color) {
+            this.r += color.r;
+            this.g += color.g;
+            this.b += color.b;
+            return this;
+        }
+        addColors(color1, color2) {
+            this.r = color1.r + color2.r;
+            this.g = color1.g + color2.g;
+            this.b = color1.b + color2.b;
+            return this;
+        }
+        addScalar(s) {
+            this.r += s;
+            this.g += s;
+            this.b += s;
+            return this;
+        }
+        sub(color) {
+            this.r = Math.max(0, this.r - color.r);
+            this.g = Math.max(0, this.g - color.g);
+            this.b = Math.max(0, this.b - color.b);
+            return this;
+        }
+        multiply(color) {
+            this.r *= color.r;
+            this.g *= color.g;
+            this.b *= color.b;
+            return this;
+        }
+        multiplyScalar(s) {
+            this.r *= s;
+            this.g *= s;
+            this.b *= s;
+            return this;
+        }
+        lerp(color, alpha) {
+            this.r += (color.r - this.r) * alpha;
+            this.g += (color.g - this.g) * alpha;
+            this.b += (color.b - this.b) * alpha;
+            return this;
+        }
+        lerpColors(color1, color2, alpha) {
+            this.r = color1.r + (color2.r - color1.r) * alpha;
+            this.g = color1.g + (color2.g - color1.g) * alpha;
+            this.b = color1.b + (color2.b - color1.b) * alpha;
+            return this;
+        }
+        lerpHSL(color, alpha) {
+            this.getHSL(_hslA);
+            color.getHSL(_hslB);
+            const h = lerp(_hslA.h, _hslB.h, alpha);
+            const s = lerp(_hslA.s, _hslB.s, alpha);
+            const l = lerp(_hslA.l, _hslB.l, alpha);
+            this.setHSL(h, s, l);
+            return this;
+        }
+        equals(c) {
+            return c.r === this.r && c.g === this.g && c.b === this.b;
+        }
+        fromArray(array, offset = 0) {
+            this.r = array[offset];
+            this.g = array[offset + 1];
+            this.b = array[offset + 2];
+            return this;
+        }
+        toArray(array = [], offset = 0) {
+            array[offset] = this.r;
+            array[offset + 1] = this.g;
+            array[offset + 2] = this.b;
+            return array;
+        }
+        fromBufferAttribute(attribute, index) {
+            this.r = attribute.getX(index);
+            this.g = attribute.getY(index);
+            this.b = attribute.getZ(index);
+            if (attribute.normalized === true) {
+                // assuming Uint8Array
+                this.r /= 255;
+                this.g /= 255;
+                this.b /= 255;
+            }
+            return this;
+        }
+        toJSON() {
+            return this.getHex();
+        }
+    }
+    //#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];
@@ -116,17 +737,427 @@ function workerFunction() {
             return this;
         }
     }
+    class Vector2 {
+        constructor(x = 0, y = 0) {
+            this.x = x;
+            this.y = y;
+        }
+        get width() {
+            return this.x;
+        }
+        set width(value) {
+            this.x = value;
+        }
+        get height() {
+            return this.y;
+        }
+        set height(value) {
+            this.y = value;
+        }
+        set(x, y) {
+            this.x = x;
+            this.y = y;
+            return this;
+        }
+        setScalar(scalar) {
+            this.x = scalar;
+            this.y = scalar;
+            return this;
+        }
+        setX(x) {
+            this.x = x;
+            return this;
+        }
+        setY(y) {
+            this.y = y;
+            return this;
+        }
+        setComponent(index, value) {
+            switch (index) {
+                case 0:
+                    this.x = value;
+                    break;
+                case 1:
+                    this.y = value;
+                    break;
+                default:
+                    throw new Error('index is out of range: ' + index);
+            }
+            return this;
+        }
+        getComponent(index) {
+            switch (index) {
+                case 0:
+                    return this.x;
+                case 1:
+                    return this.y;
+                default:
+                    throw new Error('index is out of range: ' + index);
+            }
+        }
+        clone() {
+            return new this.constructor(this.x, this.y);
+        }
+        copy(v) {
+            this.x = v.x;
+            this.y = v.y;
+            return this;
+        }
+        add(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
+                return this.addVectors(v, w);
+            }
+            this.x += v.x;
+            this.y += v.y;
+            return this;
+        }
+        addScalar(s) {
+            this.x += s;
+            this.y += s;
+            return this;
+        }
+        addVectors(a, b) {
+            this.x = a.x + b.x;
+            this.y = a.y + b.y;
+            return this;
+        }
+        addScaledVector(v, s) {
+            this.x += v.x * s;
+            this.y += v.y * s;
+            return this;
+        }
+        sub(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
+                return this.subVectors(v, w);
+            }
+            this.x -= v.x;
+            this.y -= v.y;
+            return this;
+        }
+        subScalar(s) {
+            this.x -= s;
+            this.y -= s;
+            return this;
+        }
+        subVectors(a, b) {
+            this.x = a.x - b.x;
+            this.y = a.y - b.y;
+            return this;
+        }
+        multiply(v) {
+            this.x *= v.x;
+            this.y *= v.y;
+            return this;
+        }
+        multiplyScalar(scalar) {
+            this.x *= scalar;
+            this.y *= scalar;
+            return this;
+        }
+        divide(v) {
+            this.x /= v.x;
+            this.y /= v.y;
+            return this;
+        }
+        divideScalar(scalar) {
+            return this.multiplyScalar(1 / scalar);
+        }
+        applyMatrix3(m) {
+            const x = this.x, y = this.y;
+            const e = m.elements;
+            this.x = e[0] * x + e[3] * y + e[6];
+            this.y = e[1] * x + e[4] * y + e[7];
+            return this;
+        }
+        min(v) {
+            this.x = Math.min(this.x, v.x);
+            this.y = Math.min(this.y, v.y);
+            return this;
+        }
+        max(v) {
+            this.x = Math.max(this.x, v.x);
+            this.y = Math.max(this.y, v.y);
+            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));
+            return this;
+        }
+        clampScalar(minVal, maxVal) {
+            this.x = Math.max(minVal, Math.min(maxVal, this.x));
+            this.y = Math.max(minVal, Math.min(maxVal, this.y));
+            return this;
+        }
+        clampLength(min, max) {
+            const length = this.length();
+            return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
+        }
+        floor() {
+            this.x = Math.floor(this.x);
+            this.y = Math.floor(this.y);
+            return this;
+        }
+        ceil() {
+            this.x = Math.ceil(this.x);
+            this.y = Math.ceil(this.y);
+            return this;
+        }
+        round() {
+            this.x = Math.round(this.x);
+            this.y = Math.round(this.y);
+            return this;
+        }
+        roundToZero() {
+            this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x);
+            this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y);
+            return this;
+        }
+        negate() {
+            this.x = -this.x;
+            this.y = -this.y;
+            return this;
+        }
+        dot(v) {
+            return this.x * v.x + this.y * v.y;
+        }
+        cross(v) {
+            return this.x * v.y - this.y * v.x;
+        }
+        lengthSq() {
+            return this.x * this.x + this.y * this.y;
+        }
+        length() {
+            return Math.sqrt(this.x * this.x + this.y * this.y);
+        }
+        manhattanLength() {
+            return Math.abs(this.x) + Math.abs(this.y);
+        }
+        normalize() {
+            return this.divideScalar(this.length() || 1);
+        }
+        angle() {
+            // computes the angle in radians with respect to the positive x-axis
+            const angle = Math.atan2(-this.y, -this.x) + Math.PI;
+            return angle;
+        }
+        distanceTo(v) {
+            return Math.sqrt(this.distanceToSquared(v));
+        }
+        distanceToSquared(v) {
+            const dx = this.x - v.x, dy = this.y - v.y;
+            return dx * dx + dy * dy;
+        }
+        manhattanDistanceTo(v) {
+            return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
+        }
+        setLength(length) {
+            return this.normalize().multiplyScalar(length);
+        }
+        lerp(v, alpha) {
+            this.x += (v.x - this.x) * alpha;
+            this.y += (v.y - this.y) * alpha;
+            return this;
+        }
+        lerpVectors(v1, v2, alpha) {
+            this.x = v1.x + (v2.x - v1.x) * alpha;
+            this.y = v1.y + (v2.y - v1.y) * alpha;
+            return this;
+        }
+        equals(v) {
+            return v.x === this.x && v.y === this.y;
+        }
+        fromArray(array, offset = 0) {
+            this.x = array[offset];
+            this.y = array[offset + 1];
+            return this;
+        }
+        toArray(array = [], offset = 0) {
+            array[offset] = this.x;
+            array[offset + 1] = this.y;
+            return array;
+        }
+        fromBufferAttribute(attribute, index, offset) {
+            if (offset !== undefined) {
+                console.warn('THREE.Vector2: offset has been removed from .fromBufferAttribute().');
+            }
+            this.x = attribute.getX(index);
+            this.y = attribute.getY(index);
+            return this;
+        }
+        rotateAround(center, angle) {
+            const c = Math.cos(angle), s = Math.sin(angle);
+            const x = this.x - center.x;
+            const y = this.y - center.y;
+            this.x = x * c - y * s + center.x;
+            this.y = x * s + y * c + center.y;
+            return this;
+        }
+        random() {
+            this.x = Math.random();
+            this.y = Math.random();
+            return this;
+        }
+        *[Symbol.iterator]() {
+            yield this.x;
+            yield this.y;
+        }
+    }
     class Vector3 {
-        constructor(x, y, z) {
-            this.x = 0;
-            this.y = 0;
-            this.z = 0;
+        constructor(x = 0, y = 0, z = 0) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+        set(x, y, z) {
+            if (z === undefined)
+                z = this.z; // sprite.scale.set(x, y)
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            return this;
+        }
+        setScalar(scalar) {
+            this.x = scalar;
+            this.y = scalar;
+            this.z = scalar;
+            return this;
+        }
+        setX(x) {
             this.x = x;
+            return this;
+        }
+        setY(y) {
             this.y = y;
+            return this;
+        }
+        setZ(z) {
             this.z = z;
+            return this;
+        }
+        setComponent(index, value) {
+            switch (index) {
+                case 0:
+                    this.x = value;
+                    break;
+                case 1:
+                    this.y = value;
+                    break;
+                case 2:
+                    this.z = value;
+                    break;
+                default:
+                    throw new Error('index is out of range: ' + index);
+            }
+            return this;
+        }
+        getComponent(index) {
+            switch (index) {
+                case 0:
+                    return this.x;
+                case 1:
+                    return this.y;
+                case 2:
+                    return this.z;
+                default:
+                    throw new Error('index is out of range: ' + index);
+            }
+        }
+        clone() {
+            return new Vector3(this.x, this.y, this.z);
+        }
+        copy(v) {
+            this.x = v.x;
+            this.y = v.y;
+            this.z = v.z;
+            return this;
+        }
+        add(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
+                return this.addVectors(v, w);
+            }
+            this.x += v.x;
+            this.y += v.y;
+            this.z += v.z;
+            return this;
+        }
+        addScalar(s) {
+            this.x += s;
+            this.y += s;
+            this.z += s;
+            return this;
+        }
+        addVectors(a, b) {
+            this.x = a.x + b.x;
+            this.y = a.y + b.y;
+            this.z = a.z + b.z;
+            return this;
+        }
+        addScaledVector(v, s) {
+            this.x += v.x * s;
+            this.y += v.y * s;
+            this.z += v.z * s;
+            return this;
+        }
+        sub(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
+                return this.subVectors(v, w);
+            }
+            this.x -= v.x;
+            this.y -= v.y;
+            this.z -= v.z;
+            return this;
+        }
+        subScalar(s) {
+            this.x -= s;
+            this.y -= s;
+            this.z -= s;
+            return this;
+        }
+        subVectors(a, b) {
+            this.x = a.x - b.x;
+            this.y = a.y - b.y;
+            this.z = a.z - b.z;
+            return this;
+        }
+        multiply(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.');
+                return this.multiplyVectors(v, w);
+            }
+            this.x *= v.x;
+            this.y *= v.y;
+            this.z *= v.z;
+            return this;
+        }
+        multiplyScalar(scalar) {
+            this.x *= scalar;
+            this.y *= scalar;
+            this.z *= scalar;
+            return this;
+        }
+        multiplyVectors(a, b) {
+            this.x = a.x * b.x;
+            this.y = a.y * b.y;
+            this.z = a.z * b.z;
+            return this;
+        }
+        applyMatrix3(m) {
+            const x = this.x, y = this.y;
+            const e = m.elements;
+            this.x = e[0] * x + e[3] * y + e[6];
+            this.y = e[1] * x + e[4] * y + e[7];
+            return this;
         }
         applyMatrix4(m) {
-            const x = this.x, y = this.y, z = this.z;
+            const x = this.x;
+            const y = this.y;
+            const z = this.z;
             const e = m.elements;
             const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
             this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
@@ -134,7 +1165,1299 @@ function workerFunction() {
             this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
             return this;
         }
+        setFromMatrix3Column(m, index) {
+            return this.fromArray(m.elements, index * 3);
+        }
+        fromArray(array, offset = 0) {
+            this.x = array[offset];
+            this.y = array[offset + 1];
+            this.z = array[offset + 2];
+            return this;
+        }
+        toArray(array = [], offset = 0) {
+            array[offset] = this.x;
+            array[offset + 1] = this.y;
+            array[offset + 2] = this.z;
+            return array;
+        }
+        fromBufferAttribute(attribute, index, offset) {
+            if (offset !== undefined) {
+                console.warn('THREE.Vector3: offset has been removed from .fromBufferAttribute().');
+            }
+            this.x = attribute.getX(index);
+            this.y = attribute.getY(index);
+            this.z = attribute.getZ(index);
+            return this;
+        }
+        applyNormalMatrix(m) {
+            this.applyMatrix3(m);
+            this.normalize();
+            return this;
+        }
+        normalize() {
+            const length = this.length() || 1;
+            return this.divideScalar(length);
+        }
+        length() {
+            return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+        }
+        divideScalar(scalar) {
+            return this.multiplyScalar(1 / scalar);
+        }
+        transformDirection(m) {
+            const x = this.x, y = this.y, z = this.z;
+            const e = m.elements;
+            this.x = e[0] * x + e[4] * y + e[8] * z;
+            this.y = e[1] * x + e[5] * y + e[9] * z;
+            this.z = e[2] * x + e[6] * y + e[10] * z;
+            return this.normalize();
+        }
+    }
+    class Vector4 {
+        constructor(x = 0, y = 0, z = 0, w = 1) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.w = w;
+        }
+        get width() {
+            return this.z;
+        }
+        set width(value) {
+            this.z = value;
+        }
+        get height() {
+            return this.w;
+        }
+        set height(value) {
+            this.w = value;
+        }
+        set(x, y, z, w) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.w = w;
+            return this;
+        }
+        setScalar(scalar) {
+            this.x = scalar;
+            this.y = scalar;
+            this.z = scalar;
+            this.w = scalar;
+            return this;
+        }
+        setX(x) {
+            this.x = x;
+            return this;
+        }
+        setY(y) {
+            this.y = y;
+            return this;
+        }
+        setZ(z) {
+            this.z = z;
+            return this;
+        }
+        setW(w) {
+            this.w = w;
+            return this;
+        }
+        setComponent(index, value) {
+            switch (index) {
+                case 0:
+                    this.x = value;
+                    break;
+                case 1:
+                    this.y = value;
+                    break;
+                case 2:
+                    this.z = value;
+                    break;
+                case 3:
+                    this.w = value;
+                    break;
+                default:
+                    throw new Error('index is out of range: ' + index);
+            }
+            return this;
+        }
+        getComponent(index) {
+            switch (index) {
+                case 0:
+                    return this.x;
+                case 1:
+                    return this.y;
+                case 2:
+                    return this.z;
+                case 3:
+                    return this.w;
+                default:
+                    throw new Error('index is out of range: ' + index);
+            }
+        }
+        clone() {
+            return new this.constructor(this.x, this.y, this.z, this.w);
+        }
+        copy(v) {
+            this.x = v.x;
+            this.y = v.y;
+            this.z = v.z;
+            this.w = v.w !== undefined ? v.w : 1;
+            return this;
+        }
+        add(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
+                return this.addVectors(v, w);
+            }
+            this.x += v.x;
+            this.y += v.y;
+            this.z += v.z;
+            this.w += v.w;
+            return this;
+        }
+        addScalar(s) {
+            this.x += s;
+            this.y += s;
+            this.z += s;
+            this.w += s;
+            return this;
+        }
+        addVectors(a, b) {
+            this.x = a.x + b.x;
+            this.y = a.y + b.y;
+            this.z = a.z + b.z;
+            this.w = a.w + b.w;
+            return this;
+        }
+        addScaledVector(v, s) {
+            this.x += v.x * s;
+            this.y += v.y * s;
+            this.z += v.z * s;
+            this.w += v.w * s;
+            return this;
+        }
+        sub(v, w) {
+            if (w !== undefined) {
+                console.warn('THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
+                return this.subVectors(v, w);
+            }
+            this.x -= v.x;
+            this.y -= v.y;
+            this.z -= v.z;
+            this.w -= v.w;
+            return this;
+        }
+        subScalar(s) {
+            this.x -= s;
+            this.y -= s;
+            this.z -= s;
+            this.w -= s;
+            return this;
+        }
+        subVectors(a, b) {
+            this.x = a.x - b.x;
+            this.y = a.y - b.y;
+            this.z = a.z - b.z;
+            this.w = a.w - b.w;
+            return this;
+        }
+        multiply(v) {
+            this.x *= v.x;
+            this.y *= v.y;
+            this.z *= v.z;
+            this.w *= v.w;
+            return this;
+        }
+        multiplyScalar(scalar) {
+            this.x *= scalar;
+            this.y *= scalar;
+            this.z *= scalar;
+            this.w *= scalar;
+            return this;
+        }
+        applyMatrix4(m) {
+            const x = this.x, y = this.y, z = this.z, w = this.w;
+            const e = m.elements;
+            this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w;
+            this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w;
+            this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w;
+            this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w;
+            return this;
+        }
+        divideScalar(scalar) {
+            return this.multiplyScalar(1 / scalar);
+        }
+        setAxisAngleFromQuaternion(q) {
+            this.w = 2 * Math.acos(q.w);
+            const s = Math.sqrt(1 - q.w * q.w);
+            if (s < 0.0001) {
+                this.x = 1;
+                this.y = 0;
+                this.z = 0;
+            }
+            else {
+                this.x = q.x / s;
+                this.y = q.y / s;
+                this.z = q.z / s;
+            }
+            return this;
+        }
+        setAxisAngleFromRotationMatrix(m) {
+            const epsilon = 0.01;
+            const epsilon2 = 0.1;
+            const te = m.elements;
+            const m11 = te[0], m12 = te[4], m13 = te[8];
+            const m21 = te[1], m22 = te[5], m23 = te[9];
+            const m31 = te[2], m32 = te[6], m33 = te[10];
+            if (Math.abs(m12 - m21) < epsilon &&
+                Math.abs(m13 - m31) < epsilon &&
+                Math.abs(m23 - m32) < epsilon) {
+                if (Math.abs(m12 + m21) < epsilon2 &&
+                    Math.abs(m13 + m31) < epsilon2 &&
+                    Math.abs(m23 + m32) < epsilon2 &&
+                    Math.abs(m11 + m22 + m33 - 3) < epsilon2) {
+                    this.set(1, 0, 0, 0);
+                    return this;
+                }
+                this.set(0, 0.707106781, 0.707106781, Math.PI);
+                return this;
+            }
+            let s = Math.sqrt((m32 - m23) * (m32 - m23) +
+                (m13 - m31) * (m13 - m31) +
+                (m21 - m12) * (m21 - m12));
+            if (Math.abs(s) < 0.001)
+                s = 1;
+            this.x = (m32 - m23) / s;
+            this.y = (m13 - m31) / s;
+            this.z = (m21 - m12) / s;
+            this.w = Math.acos((m11 + m22 + m33 - 1) / 2);
+            return this;
+        }
+        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);
+            this.w = Math.min(this.w, v.w);
+            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);
+            this.w = Math.max(this.w, v.w);
+            return this;
+        }
+        clamp(min, max) {
+            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));
+            this.w = Math.max(min.w, Math.min(max.w, this.w));
+            return this;
+        }
+        clampScalar(minVal, maxVal) {
+            this.x = Math.max(minVal, Math.min(maxVal, this.x));
+            this.y = Math.max(minVal, Math.min(maxVal, this.y));
+            this.z = Math.max(minVal, Math.min(maxVal, this.z));
+            this.w = Math.max(minVal, Math.min(maxVal, this.w));
+            return this;
+        }
+        clampLength(min, max) {
+            const length = this.length();
+            return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
+        }
+        floor() {
+            this.x = Math.floor(this.x);
+            this.y = Math.floor(this.y);
+            this.z = Math.floor(this.z);
+            this.w = Math.floor(this.w);
+            return this;
+        }
+        ceil() {
+            this.x = Math.ceil(this.x);
+            this.y = Math.ceil(this.y);
+            this.z = Math.ceil(this.z);
+            this.w = Math.ceil(this.w);
+            return this;
+        }
+        round() {
+            this.x = Math.round(this.x);
+            this.y = Math.round(this.y);
+            this.z = Math.round(this.z);
+            this.w = Math.round(this.w);
+            return this;
+        }
+        roundToZero() {
+            this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x);
+            this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y);
+            this.z = this.z < 0 ? Math.ceil(this.z) : Math.floor(this.z);
+            this.w = this.w < 0 ? Math.ceil(this.w) : Math.floor(this.w);
+            return this;
+        }
+        negate() {
+            this.x = -this.x;
+            this.y = -this.y;
+            this.z = -this.z;
+            this.w = -this.w;
+            return this;
+        }
+        dot(v) {
+            return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+        }
+        lengthSq() {
+            return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+        }
+        length() {
+            return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+        }
+        manhattanLength() {
+            return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w);
+        }
+        normalize() {
+            return this.divideScalar(this.length() || 1);
+        }
+        setLength(length) {
+            return this.normalize().multiplyScalar(length);
+        }
+        lerp(v, alpha) {
+            this.x += (v.x - this.x) * alpha;
+            this.y += (v.y - this.y) * alpha;
+            this.z += (v.z - this.z) * alpha;
+            this.w += (v.w - this.w) * alpha;
+            return this;
+        }
+        lerpVectors(v1, v2, alpha) {
+            this.x = v1.x + (v2.x - v1.x) * alpha;
+            this.y = v1.y + (v2.y - v1.y) * alpha;
+            this.z = v1.z + (v2.z - v1.z) * alpha;
+            this.w = v1.w + (v2.w - v1.w) * alpha;
+            return this;
+        }
+        equals(v) {
+            return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w;
+        }
+        fromArray(array, offset = 0) {
+            this.x = array[offset];
+            this.y = array[offset + 1];
+            this.z = array[offset + 2];
+            this.w = array[offset + 3];
+            return this;
+        }
+        toArray(array = [], offset = 0) {
+            array[offset] = this.x;
+            array[offset + 1] = this.y;
+            array[offset + 2] = this.z;
+            array[offset + 3] = this.w;
+            return array;
+        }
+        fromBufferAttribute(attribute, index, offset) {
+            if (offset !== undefined) {
+                console.warn('THREE.Vector4: offset has been removed from .fromBufferAttribute().');
+            }
+            this.x = attribute.getX(index);
+            this.y = attribute.getY(index);
+            this.z = attribute.getZ(index);
+            this.w = attribute.getW(index);
+            return this;
+        }
+        random() {
+            this.x = Math.random();
+            this.y = Math.random();
+            this.z = Math.random();
+            this.w = Math.random();
+            return this;
+        }
+        *[Symbol.iterator]() {
+            yield this.x;
+            yield this.y;
+            yield this.z;
+            yield this.w;
+        }
+    }
+    class Matrix3 {
+        constructor() {
+            this.elements = [
+                1, 0, 0,
+                0, 1, 0,
+                0, 0, 1
+            ];
+            if (arguments.length > 0) {
+                console.error('THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.');
+            }
+        }
+        set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
+            const te = this.elements;
+            te[0] = n11;
+            te[1] = n21;
+            te[2] = n31;
+            te[3] = n12;
+            te[4] = n22;
+            te[5] = n32;
+            te[6] = n13;
+            te[7] = n23;
+            te[8] = n33;
+            return this;
+        }
+        identity() {
+            this.set(1, 0, 0, 0, 1, 0, 0, 0, 1);
+            return this;
+        }
+        copy(m) {
+            const te = this.elements;
+            const me = m.elements;
+            te[0] = me[0];
+            te[1] = me[1];
+            te[2] = me[2];
+            te[3] = me[3];
+            te[4] = me[4];
+            te[5] = me[5];
+            te[6] = me[6];
+            te[7] = me[7];
+            te[8] = me[8];
+            return this;
+        }
+        extractBasis(xAxis, yAxis, zAxis) {
+            xAxis.setFromMatrix3Column(this, 0);
+            yAxis.setFromMatrix3Column(this, 1);
+            zAxis.setFromMatrix3Column(this, 2);
+            return this;
+        }
+        setFromMatrix4(m) {
+            const me = m.elements;
+            this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10]);
+            return this;
+        }
+        multiply(m) {
+            return this.multiplyMatrices(this, m);
+        }
+        premultiply(m) {
+            return this.multiplyMatrices(m, this);
+        }
+        multiplyMatrices(a, b) {
+            const ae = a.elements;
+            const be = b.elements;
+            const te = this.elements;
+            const a11 = ae[0], a12 = ae[3], a13 = ae[6];
+            const a21 = ae[1], a22 = ae[4], a23 = ae[7];
+            const a31 = ae[2], a32 = ae[5], a33 = ae[8];
+            const b11 = be[0], b12 = be[3], b13 = be[6];
+            const b21 = be[1], b22 = be[4], b23 = be[7];
+            const b31 = be[2], b32 = be[5], b33 = be[8];
+            te[0] = a11 * b11 + a12 * b21 + a13 * b31;
+            te[3] = a11 * b12 + a12 * b22 + a13 * b32;
+            te[6] = a11 * b13 + a12 * b23 + a13 * b33;
+            te[1] = a21 * b11 + a22 * b21 + a23 * b31;
+            te[4] = a21 * b12 + a22 * b22 + a23 * b32;
+            te[7] = a21 * b13 + a22 * b23 + a23 * b33;
+            te[2] = a31 * b11 + a32 * b21 + a33 * b31;
+            te[5] = a31 * b12 + a32 * b22 + a33 * b32;
+            te[8] = a31 * b13 + a32 * b23 + a33 * b33;
+            return this;
+        }
+        multiplyScalar(s) {
+            const te = this.elements;
+            te[0] *= s;
+            te[3] *= s;
+            te[6] *= s;
+            te[1] *= s;
+            te[4] *= s;
+            te[7] *= s;
+            te[2] *= s;
+            te[5] *= s;
+            te[8] *= s;
+            return this;
+        }
+        determinant() {
+            const te = this.elements;
+            const a = te[0], b = te[1], c = te[2], d = te[3], e = te[4], f = te[5], g = te[6], h = te[7], i = te[8];
+            return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
+        }
+        invert() {
+            const te = this.elements;
+            const n11 = te[0], n21 = te[1], n31 = te[2], n12 = te[3], n22 = te[4], n32 = te[5], n13 = te[6], n23 = te[7], n33 = te[8], t11 = n33 * n22 - n32 * n23, t12 = n32 * n13 - n33 * n12, t13 = n23 * n12 - n22 * n13, det = n11 * t11 + n21 * t12 + n31 * t13;
+            if (det === 0)
+                return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
+            const detInv = 1 / det;
+            te[0] = t11 * detInv;
+            te[1] = (n31 * n23 - n33 * n21) * detInv;
+            te[2] = (n32 * n21 - n31 * n22) * detInv;
+            te[3] = t12 * detInv;
+            te[4] = (n33 * n11 - n31 * n13) * detInv;
+            te[5] = (n31 * n12 - n32 * n11) * detInv;
+            te[6] = t13 * detInv;
+            te[7] = (n21 * n13 - n23 * n11) * detInv;
+            te[8] = (n22 * n11 - n21 * n12) * detInv;
+            return this;
+        }
+        transpose() {
+            let tmp;
+            const m = this.elements;
+            tmp = m[1];
+            m[1] = m[3];
+            m[3] = tmp;
+            tmp = m[2];
+            m[2] = m[6];
+            m[6] = tmp;
+            tmp = m[5];
+            m[5] = m[7];
+            m[7] = tmp;
+            return this;
+        }
+        getNormalMatrix(matrix4) {
+            return this.setFromMatrix4(matrix4).invert().transpose();
+        }
+        transposeIntoArray(r) {
+            const m = this.elements;
+            r[0] = m[0];
+            r[1] = m[3];
+            r[2] = m[6];
+            r[3] = m[1];
+            r[4] = m[4];
+            r[5] = m[7];
+            r[6] = m[2];
+            r[7] = m[5];
+            r[8] = m[8];
+            return this;
+        }
+        setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
+            const c = Math.cos(rotation);
+            const s = Math.sin(rotation);
+            this.set(sx * c, sx * s, -sx * (c * cx + s * cy) + cx + tx, -sy * s, sy * c, -sy * (-s * cx + c * cy) + cy + ty, 0, 0, 1);
+            return this;
+        }
+        scale(sx, sy) {
+            const te = this.elements;
+            te[0] *= sx;
+            te[3] *= sx;
+            te[6] *= sx;
+            te[1] *= sy;
+            te[4] *= sy;
+            te[7] *= sy;
+            return this;
+        }
+        rotate(theta) {
+            const c = Math.cos(theta);
+            const s = Math.sin(theta);
+            const te = this.elements;
+            const a11 = te[0], a12 = te[3], a13 = te[6];
+            const a21 = te[1], a22 = te[4], a23 = te[7];
+            te[0] = c * a11 + s * a21;
+            te[3] = c * a12 + s * a22;
+            te[6] = c * a13 + s * a23;
+            te[1] = -s * a11 + c * a21;
+            te[4] = -s * a12 + c * a22;
+            te[7] = -s * a13 + c * a23;
+            return this;
+        }
+        translate(tx, ty) {
+            const te = this.elements;
+            te[0] += tx * te[2];
+            te[3] += tx * te[5];
+            te[6] += tx * te[8];
+            te[1] += ty * te[2];
+            te[4] += ty * te[5];
+            te[7] += ty * te[8];
+            return this;
+        }
+        equals(matrix) {
+            const te = this.elements;
+            const me = matrix.elements;
+            for (let i = 0; i < 9; i++) {
+                if (te[i] !== me[i])
+                    return false;
+            }
+            return true;
+        }
+        fromArray(array, offset = 0) {
+            for (let i = 0; i < 9; i++) {
+                this.elements[i] = array[i + offset];
+            }
+            return this;
+        }
+        toArray(array = [], offset = 0) {
+            const te = this.elements;
+            array[offset] = te[0];
+            array[offset + 1] = te[1];
+            array[offset + 2] = te[2];
+            array[offset + 3] = te[3];
+            array[offset + 4] = te[4];
+            array[offset + 5] = te[5];
+            array[offset + 6] = te[6];
+            array[offset + 7] = te[7];
+            array[offset + 8] = te[8];
+            return array;
+        }
+        clone() {
+            return new Matrix3().fromArray(this.elements);
+        }
+    }
+    //#endregion
+    const _vector$9 = /*@__PURE__*/ new Vector3(0, 0, 0);
+    const _vector2$1 = /*@__PURE__*/ new Vector2();
+    class BufferAttribute {
+        constructor(array, itemSize, normalized) {
+            this.name = '';
+            if (Array.isArray(array)) {
+                throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.');
+            }
+            this.array = array;
+            this.itemSize = itemSize;
+            this.count = array !== undefined ? array.length / itemSize : 0;
+            this.normalized = normalized === true;
+            this.usage = StaticDrawUsage;
+            this.updateRange = { offset: 0, count: -1 };
+            this.version = 0;
+        }
+        onUploadCallback() { }
+        set needsUpdate(value) {
+            if (value === true)
+                this.version++;
+        }
+        setUsage(value) {
+            this.usage = value;
+            return this;
+        }
+        copy(source) {
+            this.name = source.name;
+            this.array = source.array;
+            this.itemSize = source.itemSize;
+            this.count = source.count;
+            this.normalized = source.normalized;
+            this.usage = source.usage;
+            return this;
+        }
+        copyAt(index1, attribute, index2) {
+            index1 *= this.itemSize;
+            index2 *= attribute.itemSize;
+            for (let i = 0, l = this.itemSize; i < l; i++) {
+                this.array[index1 + i] = attribute.array[index2 + i];
+            }
+            return this;
+        }
+        copyArray(array) {
+            this.array.set(array);
+            return this;
+        }
+        copyColorsArray(colors) {
+            const array = this.array;
+            let offset = 0;
+            for (let i = 0, l = colors.length; i < l; i++) {
+                let color = colors[i];
+                if (color === undefined) {
+                    console.warn('THREE.BufferAttribute.copyColorsArray(): color is undefined', i);
+                    color = new Color(255, 255, 255);
+                }
+                array[offset++] = color.r;
+                array[offset++] = color.g;
+                array[offset++] = color.b;
+            }
+            return this;
+        }
+        copyVector2sArray(vectors) {
+            const array = this.array;
+            let offset = 0;
+            for (let i = 0, l = vectors.length; i < l; i++) {
+                let vector = vectors[i];
+                if (vector === undefined) {
+                    console.warn('THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i);
+                    vector = new Vector2();
+                }
+                array[offset++] = vector.x;
+                array[offset++] = vector.y;
+            }
+            return this;
+        }
+        copyVector3sArray(vectors) {
+            const array = this.array;
+            let offset = 0;
+            for (let i = 0, l = vectors.length; i < l; i++) {
+                let vector = vectors[i];
+                if (vector === undefined) {
+                    console.warn('THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i);
+                    vector = new Vector3(0, 0, 0);
+                }
+                array[offset++] = vector.x;
+                array[offset++] = vector.y;
+                array[offset++] = vector.z;
+            }
+            return this;
+        }
+        copyVector4sArray(vectors) {
+            const array = this.array;
+            let offset = 0;
+            for (let i = 0, l = vectors.length; i < l; i++) {
+                let vector = vectors[i];
+                if (vector === undefined) {
+                    console.warn('THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i);
+                    vector = new Vector4();
+                }
+                array[offset++] = vector.x;
+                array[offset++] = vector.y;
+                array[offset++] = vector.z;
+                array[offset++] = vector.w;
+            }
+            return this;
+        }
+        applyMatrix3(m) {
+            if (this.itemSize === 2) {
+                for (let i = 0, l = this.count; i < l; i++) {
+                    _vector2$1.fromBufferAttribute(this, i);
+                    _vector2$1.applyMatrix3(m);
+                    this.setXY(i, _vector2$1.x, _vector2$1.y);
+                }
+            }
+            else if (this.itemSize === 3) {
+                for (let i = 0, l = this.count; i < l; i++) {
+                    _vector$9.fromBufferAttribute(this, i);
+                    _vector$9.applyMatrix3(m);
+                    this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z);
+                }
+            }
+            return this;
+        }
+        applyMatrix4(m) {
+            for (let i = 0, l = this.count; i < l; i++) {
+                _vector$9.x = this.getX(i);
+                _vector$9.y = this.getY(i);
+                _vector$9.z = this.getZ(i);
+                _vector$9.applyMatrix4(m);
+                this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z);
+            }
+            return this;
+        }
+        applyNormalMatrix(m) {
+            for (let i = 0, l = this.count; i < l; i++) {
+                _vector$9.x = this.getX(i);
+                _vector$9.y = this.getY(i);
+                _vector$9.z = this.getZ(i);
+                _vector$9.applyNormalMatrix(m);
+                this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z);
+            }
+            return this;
+        }
+        transformDirection(m) {
+            for (let i = 0, l = this.count; i < l; i++) {
+                _vector$9.x = this.getX(i);
+                _vector$9.y = this.getY(i);
+                _vector$9.z = this.getZ(i);
+                _vector$9.transformDirection(m);
+                this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z);
+            }
+            return this;
+        }
+        set(value, offset = 0) {
+            this.array.set(value, offset);
+            return this;
+        }
+        getX(index) {
+            return this.array[index * this.itemSize];
+        }
+        setX(index, x) {
+            this.array[index * this.itemSize] = x;
+            return this;
+        }
+        getY(index) {
+            return this.array[index * this.itemSize + 1];
+        }
+        setY(index, y) {
+            this.array[index * this.itemSize + 1] = y;
+            return this;
+        }
+        getZ(index) {
+            return this.array[index * this.itemSize + 2];
+        }
+        setZ(index, z) {
+            this.array[index * this.itemSize + 2] = z;
+            return this;
+        }
+        getW(index) {
+            return this.array[index * this.itemSize + 3];
+        }
+        setW(index, w) {
+            this.array[index * this.itemSize + 3] = w;
+            return this;
+        }
+        setXY(index, x, y) {
+            index *= this.itemSize;
+            this.array[index + 0] = x;
+            this.array[index + 1] = y;
+            return this;
+        }
+        setXYZ(index, x, y, z) {
+            index *= this.itemSize;
+            this.array[index + 0] = x;
+            this.array[index + 1] = y;
+            this.array[index + 2] = z;
+            return this;
+        }
+        setXYZW(index, x, y, z, w) {
+            index *= this.itemSize;
+            this.array[index + 0] = x;
+            this.array[index + 1] = y;
+            this.array[index + 2] = z;
+            this.array[index + 3] = w;
+            return this;
+        }
+        onUpload(callback) {
+            this.onUploadCallback = callback;
+            return this;
+        }
+        clone() {
+            return new this.constructor(this.array, this.itemSize).copy(this);
+        }
+        toJSON() {
+            const data = {
+                itemSize: this.itemSize,
+                type: this.array.constructor.name,
+                array: Array.prototype.slice.call(this.array),
+                normalized: this.normalized,
+                name: '',
+                usage: 0,
+                updateRange: {
+                    offset: 0,
+                    count: 0
+                }
+            };
+            if (this.name !== '')
+                data.name = this.name;
+            if (this.usage !== StaticDrawUsage)
+                data.usage = this.usage;
+            if (this.updateRange.offset !== 0 || this.updateRange.count !== -1)
+                data.updateRange = this.updateRange;
+            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' });
+    //     }
+    // }
+    //#endregion
 }
 exports.workerCode = workerFunction;
 //# sourceMappingURL=load-model-worker-2.script.js.map