viral-viewer-2 6.2.7 → 6.2.8

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

@@ -0,0 +1,2704 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerCode = void 0;
+function workerFunction() {
+    function addMesh(indices, vertices, transform = null, callback = (buffer) => { }) {
+        let verticePoints = [];
+        if (transform == null) {
+            for (let i = 0; i < indices.length; i++) {
+                const index = indices[i];
+                const point = vertices[index];
+                verticePoints.push(-point.X);
+                verticePoints.push(point.Z);
+                verticePoints.push(point.Y);
+            }
+            const buffer = new Float32Array(verticePoints);
+            callback(buffer);
+            return;
+        }
+        let numbers = [
+            transform.BasisX.X,
+            -transform.BasisX.Z,
+            -transform.BasisX.Y,
+            0,
+            -transform.BasisZ.X,
+            transform.BasisZ.Z,
+            transform.BasisZ.Y,
+            0,
+            -transform.BasisY.X,
+            transform.BasisY.Z,
+            transform.BasisY.Y,
+            0,
+            -transform.Offset.X,
+            transform.Offset.Z,
+            transform.Offset.Y,
+            1,
+        ];
+        //transform first
+        let matrix4 = new Matrix4();
+        matrix4.fromArray(numbers);
+        let newVertices = [];
+        for (let i = 0; i < vertices.length; i++) {
+            const point = vertices[i];
+            const point2 = new Vector3(-point.X, point.Z, point.Y);
+            point2.applyMatrix4(matrix4);
+            newVertices.push(point2);
+        }
+        for (let i = 0; i < indices.length; i++) {
+            const index = indices[i];
+            const point = newVertices[index];
+            verticePoints.push(point.x);
+            verticePoints.push(point.y);
+            verticePoints.push(point.z);
+        }
+        const buffer = new Float32Array(verticePoints);
+        callback(buffer);
+    }
+    function progressGeometries(json, callback = (buffer) => { }) {
+        addMesh(json.Indices, json.Vertices, json.Transform, (buffer) => {
+            callback(buffer);
+        });
+    }
+    self.addEventListener("message", (event) => {
+        progressGeometries(event.data, (buffer) => {
+            self.postMessage({
+                buffer: buffer
+            });
+        });
+    }, false);
+    //#region Threejs Types
+    const StaticDrawUsage = 35044;
+    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 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 = 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;
+            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;
+            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;
+            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();
+        }
+        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) {
+            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);
+        }
+    }
+    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 = true) {
+            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;
+        }
+    }
+    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;
+//# sourceMappingURL=load-model-worker-2.script.js.map