viral-viewer-2 6.3.0 → 6.3.1

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

@@ -1,2704 +0,0 @@
-"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