(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
	typeof define === 'function' && define.amd ? define(['exports'], factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ModelViewerElement = {}));
})(this, (function (exports) { 'use strict';

	/**
	 * @license
	 * Copyright 2019 Google LLC
	 * SPDX-License-Identifier: BSD-3-Clause
	 */ const t$2 = globalThis, e$2 = t$2.ShadowRoot && (void 0 === t$2.ShadyCSS || t$2.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, s$1 = Symbol(), o$3 = new WeakMap;
	let n$4 = class n {
	    get styleSheet() {
	        let t = this.o;
	        const s = this.t;
	        if (e$2 && void 0 === t) {
	            const e = void 0 !== s && 1 === s.length;
	            e && (t = o$3.get(s)), void 0 === t && ((this.o = t = new CSSStyleSheet).replaceSync(this.cssText), e && o$3.set(s, t));
	        }
	        return t;
	    }
	    toString() {
	        return this.cssText;
	    }
	    constructor(t, e, o){
	        if (this._$cssResult$ = true, o !== s$1) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
	        this.cssText = t, this.t = e;
	    }
	};
	const r$4 = (t)=>new n$4("string" == typeof t ? t : t + "", void 0, s$1), S$1 = (s, o)=>{
	    if (e$2) s.adoptedStyleSheets = o.map((t)=>t instanceof CSSStyleSheet ? t : t.styleSheet);
	    else for (const e of o){
	        const o = document.createElement("style"), n = t$2.litNonce;
	        void 0 !== n && o.setAttribute("nonce", n), o.textContent = e.cssText, s.appendChild(o);
	    }
	}, c$3 = e$2 ? (t)=>t : (t)=>t instanceof CSSStyleSheet ? ((t)=>{
	        let e = "";
	        for (const s of t.cssRules)e += s.cssText;
	        return r$4(e);
	    })(t) : t;

	var _Symbol, _a$a, _a1;
	/**
	 * @license
	 * Copyright 2017 Google LLC
	 * SPDX-License-Identifier: BSD-3-Clause
	 */ const { is: i$3, defineProperty: e$1, getOwnPropertyDescriptor: r$3, getOwnPropertyNames: h$1, getOwnPropertySymbols: o$2, getPrototypeOf: n$3 } = Object, a$2 = globalThis, c$2 = a$2.trustedTypes, l$1 = c$2 ? c$2.emptyScript : "", p$1 = a$2.reactiveElementPolyfillSupport, d$1 = (t, s)=>t, u$2 = {
	    toAttribute (t, s) {
	        switch(s){
	            case Boolean:
	                t = t ? l$1 : null;
	                break;
	            case Object:
	            case Array:
	                t = null == t ? t : JSON.stringify(t);
	        }
	        return t;
	    },
	    fromAttribute (t, s) {
	        let i = t;
	        switch(s){
	            case Boolean:
	                i = null !== t;
	                break;
	            case Number:
	                i = null === t ? null : Number(t);
	                break;
	            case Object:
	            case Array:
	                try {
	                    i = JSON.parse(t);
	                } catch (t) {
	                    i = null;
	                }
	        }
	        return i;
	    }
	}, f$1 = (t, s)=>!i$3(t, s), y$1 = {
	    attribute: true,
	    type: String,
	    converter: u$2,
	    reflect: false,
	    hasChanged: f$1
	};
	(_Symbol = Symbol).metadata ?? (_Symbol.metadata = Symbol("metadata")), (_a$a = a$2).litPropertyMetadata ?? (_a$a.litPropertyMetadata = new WeakMap);
	let b$1 = class b extends HTMLElement {
	    static addInitializer(t) {
	        this._$Ei(), (this.l ?? (this.l = [])).push(t);
	    }
	    static get observedAttributes() {
	        return this.finalize(), this._$Eh && [
	            ...this._$Eh.keys()
	        ];
	    }
	    static createProperty(t, s = y$1) {
	        if (s.state && (s.attribute = false), this._$Ei(), this.elementProperties.set(t, s), !s.noAccessor) {
	            const i = Symbol(), r = this.getPropertyDescriptor(t, i, s);
	            void 0 !== r && e$1(this.prototype, t, r);
	        }
	    }
	    static getPropertyDescriptor(t, s, i) {
	        const { get: e, set: h } = r$3(this.prototype, t) ?? {
	            get () {
	                return this[s];
	            },
	            set (t) {
	                this[s] = t;
	            }
	        };
	        return {
	            get () {
	                return e?.call(this);
	            },
	            set (s) {
	                const r = e?.call(this);
	                h.call(this, s), this.requestUpdate(t, r, i);
	            },
	            configurable: true,
	            enumerable: true
	        };
	    }
	    static getPropertyOptions(t) {
	        return this.elementProperties.get(t) ?? y$1;
	    }
	    static _$Ei() {
	        if (this.hasOwnProperty(d$1("elementProperties"))) return;
	        const t = n$3(this);
	        t.finalize(), void 0 !== t.l && (this.l = [
	            ...t.l
	        ]), this.elementProperties = new Map(t.elementProperties);
	    }
	    static finalize() {
	        if (this.hasOwnProperty(d$1("finalized"))) return;
	        if (this.finalized = true, this._$Ei(), this.hasOwnProperty(d$1("properties"))) {
	            const t = this.properties, s = [
	                ...h$1(t),
	                ...o$2(t)
	            ];
	            for (const i of s)this.createProperty(i, t[i]);
	        }
	        const t = this[Symbol.metadata];
	        if (null !== t) {
	            const s = litPropertyMetadata.get(t);
	            if (void 0 !== s) for (const [t, i] of s)this.elementProperties.set(t, i);
	        }
	        this._$Eh = new Map;
	        for (const [t, s] of this.elementProperties){
	            const i = this._$Eu(t, s);
	            void 0 !== i && this._$Eh.set(i, t);
	        }
	        this.elementStyles = this.finalizeStyles(this.styles);
	    }
	    static finalizeStyles(s) {
	        const i = [];
	        if (Array.isArray(s)) {
	            const e = new Set(s.flat(1 / 0).reverse());
	            for (const s of e)i.unshift(c$3(s));
	        } else void 0 !== s && i.push(c$3(s));
	        return i;
	    }
	    static _$Eu(t, s) {
	        const i = s.attribute;
	        return false === i ? void 0 : "string" == typeof i ? i : "string" == typeof t ? t.toLowerCase() : void 0;
	    }
	    _$Ev() {
	        this._$ES = new Promise((t)=>this.enableUpdating = t), this._$AL = new Map, this._$E_(), this.requestUpdate(), this.constructor.l?.forEach((t)=>t(this));
	    }
	    addController(t) {
	        (this._$EO ?? (this._$EO = new Set)).add(t), void 0 !== this.renderRoot && this.isConnected && t.hostConnected?.();
	    }
	    removeController(t) {
	        this._$EO?.delete(t);
	    }
	    _$E_() {
	        const t = new Map, s = this.constructor.elementProperties;
	        for (const i of s.keys())this.hasOwnProperty(i) && (t.set(i, this[i]), delete this[i]);
	        t.size > 0 && (this._$Ep = t);
	    }
	    createRenderRoot() {
	        const t = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
	        return S$1(t, this.constructor.elementStyles), t;
	    }
	    connectedCallback() {
	        this.renderRoot ?? (this.renderRoot = this.createRenderRoot()), this.enableUpdating(true), this._$EO?.forEach((t)=>t.hostConnected?.());
	    }
	    enableUpdating(t) {}
	    disconnectedCallback() {
	        this._$EO?.forEach((t)=>t.hostDisconnected?.());
	    }
	    attributeChangedCallback(t, s, i) {
	        this._$AK(t, i);
	    }
	    _$EC(t, s) {
	        const i = this.constructor.elementProperties.get(t), e = this.constructor._$Eu(t, i);
	        if (void 0 !== e && true === i.reflect) {
	            const r = (void 0 !== i.converter?.toAttribute ? i.converter : u$2).toAttribute(s, i.type);
	            this._$Em = t, null == r ? this.removeAttribute(e) : this.setAttribute(e, r), this._$Em = null;
	        }
	    }
	    _$AK(t, s) {
	        const i = this.constructor, e = i._$Eh.get(t);
	        if (void 0 !== e && this._$Em !== e) {
	            const t = i.getPropertyOptions(e), r = "function" == typeof t.converter ? {
	                fromAttribute: t.converter
	            } : void 0 !== t.converter?.fromAttribute ? t.converter : u$2;
	            this._$Em = e, this[e] = r.fromAttribute(s, t.type), this._$Em = null;
	        }
	    }
	    requestUpdate(t, s, i) {
	        if (void 0 !== t) {
	            if (i ?? (i = this.constructor.getPropertyOptions(t)), !(i.hasChanged ?? f$1)(this[t], s)) return;
	            this.P(t, s, i);
	        }
	        false === this.isUpdatePending && (this._$ES = this._$ET());
	    }
	    P(t, s, i) {
	        this._$AL.has(t) || this._$AL.set(t, s), true === i.reflect && this._$Em !== t && (this._$Ej ?? (this._$Ej = new Set)).add(t);
	    }
	    async _$ET() {
	        this.isUpdatePending = true;
	        try {
	            await this._$ES;
	        } catch (t) {
	            Promise.reject(t);
	        }
	        const t = this.scheduleUpdate();
	        return null != t && await t, !this.isUpdatePending;
	    }
	    scheduleUpdate() {
	        return this.performUpdate();
	    }
	    performUpdate() {
	        if (!this.isUpdatePending) return;
	        if (!this.hasUpdated) {
	            if (this.renderRoot ?? (this.renderRoot = this.createRenderRoot()), this._$Ep) {
	                for (const [t, s] of this._$Ep)this[t] = s;
	                this._$Ep = void 0;
	            }
	            const t = this.constructor.elementProperties;
	            if (t.size > 0) for (const [s, i] of t) true !== i.wrapped || this._$AL.has(s) || void 0 === this[s] || this.P(s, this[s], i);
	        }
	        let t = false;
	        const s = this._$AL;
	        try {
	            t = this.shouldUpdate(s), t ? (this.willUpdate(s), this._$EO?.forEach((t)=>t.hostUpdate?.()), this.update(s)) : this._$EU();
	        } catch (s) {
	            throw t = false, this._$EU(), s;
	        }
	        t && this._$AE(s);
	    }
	    willUpdate(t) {}
	    _$AE(t) {
	        this._$EO?.forEach((t)=>t.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t)), this.updated(t);
	    }
	    _$EU() {
	        this._$AL = new Map, this.isUpdatePending = false;
	    }
	    get updateComplete() {
	        return this.getUpdateComplete();
	    }
	    getUpdateComplete() {
	        return this._$ES;
	    }
	    shouldUpdate(t) {
	        return true;
	    }
	    update(t) {
	        this._$Ej && (this._$Ej = this._$Ej.forEach((t)=>this._$EC(t, this[t]))), this._$EU();
	    }
	    updated(t) {}
	    firstUpdated(t) {}
	    constructor(){
	        super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
	    }
	};
	b$1.elementStyles = [], b$1.shadowRootOptions = {
	    mode: "open"
	}, b$1[d$1("elementProperties")] = new Map, b$1[d$1("finalized")] = new Map, p$1?.({
	    ReactiveElement: b$1
	}), ((_a1 = a$2).reactiveElementVersions ?? (_a1.reactiveElementVersions = [])).push("2.0.4");

	/**
	 * @license
	 * Copyright 2017 Google LLC
	 * SPDX-License-Identifier: BSD-3-Clause
	 */ const o$1 = {
	    attribute: true,
	    type: String,
	    converter: u$2,
	    reflect: false,
	    hasChanged: f$1
	}, r$2 = (t = o$1, e, r)=>{
	    const { kind: n, metadata: i } = r;
	    let s = globalThis.litPropertyMetadata.get(i);
	    if (void 0 === s && globalThis.litPropertyMetadata.set(i, s = new Map), s.set(r.name, t), "accessor" === n) {
	        const { name: o } = r;
	        return {
	            set (r) {
	                const n = e.get.call(this);
	                e.set.call(this, r), this.requestUpdate(o, n, t);
	            },
	            init (e) {
	                return void 0 !== e && this.P(o, void 0, t), e;
	            }
	        };
	    }
	    if ("setter" === n) {
	        const { name: o } = r;
	        return function(r) {
	            const n = this[o];
	            e.call(this, r), this.requestUpdate(o, n, t);
	        };
	    }
	    throw Error("Unsupported decorator location: " + n);
	};
	function n$2(t) {
	    return (e, o)=>"object" == typeof o ? r$2(t, e, o) : ((t, e, o)=>{
	            const r = e.hasOwnProperty(o);
	            return e.constructor.createProperty(o, r ? {
	                ...t,
	                wrapped: true
	            } : t), r ? Object.getOwnPropertyDescriptor(e, o) : void 0;
	        })(t, e, o);
	}

	/**
	 * @license
	 * Copyright 2010-2025 Three.js Authors
	 * SPDX-License-Identifier: MIT
	 */ const REVISION = '174';
	const CullFaceNone = 0;
	const CullFaceBack = 1;
	const CullFaceFront = 2;
	const PCFShadowMap = 1;
	const PCFSoftShadowMap = 2;
	const VSMShadowMap = 3;
	const FrontSide = 0;
	const BackSide = 1;
	const DoubleSide = 2;
	const NoBlending = 0;
	const NormalBlending = 1;
	const AdditiveBlending = 2;
	const SubtractiveBlending = 3;
	const MultiplyBlending = 4;
	const CustomBlending = 5;
	const AddEquation = 100;
	const SubtractEquation = 101;
	const ReverseSubtractEquation = 102;
	const MinEquation = 103;
	const MaxEquation = 104;
	const ZeroFactor = 200;
	const OneFactor = 201;
	const SrcColorFactor = 202;
	const OneMinusSrcColorFactor = 203;
	const SrcAlphaFactor = 204;
	const OneMinusSrcAlphaFactor = 205;
	const DstAlphaFactor = 206;
	const OneMinusDstAlphaFactor = 207;
	const DstColorFactor = 208;
	const OneMinusDstColorFactor = 209;
	const SrcAlphaSaturateFactor = 210;
	const ConstantColorFactor = 211;
	const OneMinusConstantColorFactor = 212;
	const ConstantAlphaFactor = 213;
	const OneMinusConstantAlphaFactor = 214;
	const NeverDepth = 0;
	const AlwaysDepth = 1;
	const LessDepth = 2;
	const LessEqualDepth = 3;
	const EqualDepth = 4;
	const GreaterEqualDepth = 5;
	const GreaterDepth = 6;
	const NotEqualDepth = 7;
	const MultiplyOperation = 0;
	const MixOperation = 1;
	const AddOperation = 2;
	const NoToneMapping = 0;
	const LinearToneMapping = 1;
	const ReinhardToneMapping = 2;
	const CineonToneMapping = 3;
	const ACESFilmicToneMapping = 4;
	const CustomToneMapping = 5;
	const AgXToneMapping = 6;
	const NeutralToneMapping = 7;
	const AttachedBindMode = 'attached';
	const DetachedBindMode = 'detached';
	const UVMapping = 300;
	const CubeReflectionMapping = 301;
	const CubeRefractionMapping = 302;
	const EquirectangularReflectionMapping = 303;
	const EquirectangularRefractionMapping = 304;
	const CubeUVReflectionMapping = 306;
	const RepeatWrapping = 1000;
	const ClampToEdgeWrapping = 1001;
	const MirroredRepeatWrapping = 1002;
	const NearestFilter = 1003;
	const NearestMipmapNearestFilter = 1004;
	const NearestMipmapLinearFilter = 1005;
	const LinearFilter = 1006;
	const LinearMipmapNearestFilter = 1007;
	const LinearMipmapLinearFilter = 1008;
	const LinearMipMapLinearFilter = 1008;
	const UnsignedByteType = 1009;
	const ByteType = 1010;
	const ShortType = 1011;
	const UnsignedShortType = 1012;
	const IntType = 1013;
	const UnsignedIntType = 1014;
	const FloatType = 1015;
	const HalfFloatType = 1016;
	const UnsignedShort4444Type = 1017;
	const UnsignedShort5551Type = 1018;
	const UnsignedInt248Type = 1020;
	const UnsignedInt5999Type = 35902;
	const AlphaFormat = 1021;
	const RGBFormat = 1022;
	const RGBAFormat = 1023;
	const LuminanceFormat = 1024;
	const LuminanceAlphaFormat = 1025;
	const DepthFormat = 1026;
	const DepthStencilFormat = 1027;
	const RedFormat = 1028;
	const RedIntegerFormat = 1029;
	const RGFormat = 1030;
	const RGIntegerFormat = 1031;
	const RGBAIntegerFormat = 1033;
	const RGB_S3TC_DXT1_Format = 33776;
	const RGBA_S3TC_DXT1_Format = 33777;
	const RGBA_S3TC_DXT3_Format = 33778;
	const RGBA_S3TC_DXT5_Format = 33779;
	const RGB_PVRTC_4BPPV1_Format = 35840;
	const RGB_PVRTC_2BPPV1_Format = 35841;
	const RGBA_PVRTC_4BPPV1_Format = 35842;
	const RGBA_PVRTC_2BPPV1_Format = 35843;
	const RGB_ETC1_Format = 36196;
	const RGB_ETC2_Format = 37492;
	const RGBA_ETC2_EAC_Format = 37496;
	const RGBA_ASTC_4x4_Format = 37808;
	const RGBA_ASTC_5x4_Format = 37809;
	const RGBA_ASTC_5x5_Format = 37810;
	const RGBA_ASTC_6x5_Format = 37811;
	const RGBA_ASTC_6x6_Format = 37812;
	const RGBA_ASTC_8x5_Format = 37813;
	const RGBA_ASTC_8x6_Format = 37814;
	const RGBA_ASTC_8x8_Format = 37815;
	const RGBA_ASTC_10x5_Format = 37816;
	const RGBA_ASTC_10x6_Format = 37817;
	const RGBA_ASTC_10x8_Format = 37818;
	const RGBA_ASTC_10x10_Format = 37819;
	const RGBA_ASTC_12x10_Format = 37820;
	const RGBA_ASTC_12x12_Format = 37821;
	const RGBA_BPTC_Format = 36492;
	const RGB_BPTC_SIGNED_Format = 36494;
	const RGB_BPTC_UNSIGNED_Format = 36495;
	const RED_RGTC1_Format = 36283;
	const SIGNED_RED_RGTC1_Format = 36284;
	const RED_GREEN_RGTC2_Format = 36285;
	const SIGNED_RED_GREEN_RGTC2_Format = 36286;
	const LoopOnce = 2200;
	const LoopRepeat = 2201;
	const LoopPingPong = 2202;
	const InterpolateDiscrete = 2300;
	const InterpolateLinear = 2301;
	const InterpolateSmooth = 2302;
	const ZeroCurvatureEnding = 2400;
	const ZeroSlopeEnding = 2401;
	const WrapAroundEnding = 2402;
	const NormalAnimationBlendMode = 2500;
	const AdditiveAnimationBlendMode = 2501;
	const TrianglesDrawMode = 0;
	const TriangleStripDrawMode = 1;
	const TriangleFanDrawMode = 2;
	const BasicDepthPacking = 3200;
	const RGBADepthPacking = 3201;
	const TangentSpaceNormalMap = 0;
	const ObjectSpaceNormalMap = 1;
	// Color space string identifiers, matching CSS Color Module Level 4 and WebGPU names where available.
	const NoColorSpace = '';
	const SRGBColorSpace = 'srgb';
	const LinearSRGBColorSpace = 'srgb-linear';
	const LinearTransfer = 'linear';
	const SRGBTransfer = 'srgb';
	const KeepStencilOp = 7680;
	const AlwaysStencilFunc = 519;
	const NeverCompare = 512;
	const LessCompare = 513;
	const EqualCompare = 514;
	const LessEqualCompare = 515;
	const GreaterCompare = 516;
	const NotEqualCompare = 517;
	const GreaterEqualCompare = 518;
	const AlwaysCompare = 519;
	const StaticDrawUsage = 35044;
	const GLSL3 = '300 es';
	const WebGLCoordinateSystem = 2000;
	const WebGPUCoordinateSystem = 2001;
	/**
	 * This modules allows to dispatch event objects on custom JavaScript objects.
	 *
	 * Main repository: [eventdispatcher.js]{@link https://github.com/mrdoob/eventdispatcher.js/}
	 *
	 * Code Example:
	 * ```js
	 * class Car extends EventDispatcher {
	 * 	start() {
	 *		this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
	 *	}
	 *};
	 *
	 * // Using events with the custom object
	 * const car = new Car();
	 * car.addEventListener( 'start', function ( event ) {
	 * 	alert( event.message );
	 * } );
	 *
	 * car.start();
	 * ```
	 */ class EventDispatcher {
	    /**
		 * Adds the given event listener to the given event type.
		 *
		 * @param {string} type - The type of event to listen to.
		 * @param {Function} listener - The function that gets called when the event is fired.
		 */ addEventListener(type, listener) {
	        if (this._listeners === undefined) this._listeners = {};
	        const listeners = this._listeners;
	        if (listeners[type] === undefined) {
	            listeners[type] = [];
	        }
	        if (listeners[type].indexOf(listener) === -1) {
	            listeners[type].push(listener);
	        }
	    }
	    /**
		 * Returns `true` if the given event listener has been added to the given event type.
		 *
		 * @param {string} type - The type of event.
		 * @param {Function} listener - The listener to check.
		 * @return {boolean} Whether the given event listener has been added to the given event type.
		 */ hasEventListener(type, listener) {
	        const listeners = this._listeners;
	        if (listeners === undefined) return false;
	        return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1;
	    }
	    /**
		 * Removes the given event listener from the given event type.
		 *
		 * @param {string} type - The type of event.
		 * @param {Function} listener - The listener to remove.
		 */ removeEventListener(type, listener) {
	        const listeners = this._listeners;
	        if (listeners === undefined) return;
	        const listenerArray = listeners[type];
	        if (listenerArray !== undefined) {
	            const index = listenerArray.indexOf(listener);
	            if (index !== -1) {
	                listenerArray.splice(index, 1);
	            }
	        }
	    }
	    /**
		 * Dispatches an event object.
		 *
		 * @param {Object} event - The event that gets fired.
		 */ dispatchEvent(event) {
	        const listeners = this._listeners;
	        if (listeners === undefined) return;
	        const listenerArray = listeners[event.type];
	        if (listenerArray !== undefined) {
	            event.target = this;
	            // Make a copy, in case listeners are removed while iterating.
	            const array = listenerArray.slice(0);
	            for(let i = 0, l = array.length; i < l; i++){
	                array[i].call(this, event);
	            }
	            event.target = null;
	        }
	    }
	}
	const _lut = [
	    '00',
	    '01',
	    '02',
	    '03',
	    '04',
	    '05',
	    '06',
	    '07',
	    '08',
	    '09',
	    '0a',
	    '0b',
	    '0c',
	    '0d',
	    '0e',
	    '0f',
	    '10',
	    '11',
	    '12',
	    '13',
	    '14',
	    '15',
	    '16',
	    '17',
	    '18',
	    '19',
	    '1a',
	    '1b',
	    '1c',
	    '1d',
	    '1e',
	    '1f',
	    '20',
	    '21',
	    '22',
	    '23',
	    '24',
	    '25',
	    '26',
	    '27',
	    '28',
	    '29',
	    '2a',
	    '2b',
	    '2c',
	    '2d',
	    '2e',
	    '2f',
	    '30',
	    '31',
	    '32',
	    '33',
	    '34',
	    '35',
	    '36',
	    '37',
	    '38',
	    '39',
	    '3a',
	    '3b',
	    '3c',
	    '3d',
	    '3e',
	    '3f',
	    '40',
	    '41',
	    '42',
	    '43',
	    '44',
	    '45',
	    '46',
	    '47',
	    '48',
	    '49',
	    '4a',
	    '4b',
	    '4c',
	    '4d',
	    '4e',
	    '4f',
	    '50',
	    '51',
	    '52',
	    '53',
	    '54',
	    '55',
	    '56',
	    '57',
	    '58',
	    '59',
	    '5a',
	    '5b',
	    '5c',
	    '5d',
	    '5e',
	    '5f',
	    '60',
	    '61',
	    '62',
	    '63',
	    '64',
	    '65',
	    '66',
	    '67',
	    '68',
	    '69',
	    '6a',
	    '6b',
	    '6c',
	    '6d',
	    '6e',
	    '6f',
	    '70',
	    '71',
	    '72',
	    '73',
	    '74',
	    '75',
	    '76',
	    '77',
	    '78',
	    '79',
	    '7a',
	    '7b',
	    '7c',
	    '7d',
	    '7e',
	    '7f',
	    '80',
	    '81',
	    '82',
	    '83',
	    '84',
	    '85',
	    '86',
	    '87',
	    '88',
	    '89',
	    '8a',
	    '8b',
	    '8c',
	    '8d',
	    '8e',
	    '8f',
	    '90',
	    '91',
	    '92',
	    '93',
	    '94',
	    '95',
	    '96',
	    '97',
	    '98',
	    '99',
	    '9a',
	    '9b',
	    '9c',
	    '9d',
	    '9e',
	    '9f',
	    'a0',
	    'a1',
	    'a2',
	    'a3',
	    'a4',
	    'a5',
	    'a6',
	    'a7',
	    'a8',
	    'a9',
	    'aa',
	    'ab',
	    'ac',
	    'ad',
	    'ae',
	    'af',
	    'b0',
	    'b1',
	    'b2',
	    'b3',
	    'b4',
	    'b5',
	    'b6',
	    'b7',
	    'b8',
	    'b9',
	    'ba',
	    'bb',
	    'bc',
	    'bd',
	    'be',
	    'bf',
	    'c0',
	    'c1',
	    'c2',
	    'c3',
	    'c4',
	    'c5',
	    'c6',
	    'c7',
	    'c8',
	    'c9',
	    'ca',
	    'cb',
	    'cc',
	    'cd',
	    'ce',
	    'cf',
	    'd0',
	    'd1',
	    'd2',
	    'd3',
	    'd4',
	    'd5',
	    'd6',
	    'd7',
	    'd8',
	    'd9',
	    'da',
	    'db',
	    'dc',
	    'dd',
	    'de',
	    'df',
	    'e0',
	    'e1',
	    'e2',
	    'e3',
	    'e4',
	    'e5',
	    'e6',
	    'e7',
	    'e8',
	    'e9',
	    'ea',
	    'eb',
	    'ec',
	    'ed',
	    'ee',
	    'ef',
	    'f0',
	    'f1',
	    'f2',
	    'f3',
	    'f4',
	    'f5',
	    'f6',
	    'f7',
	    'f8',
	    'f9',
	    'fa',
	    'fb',
	    'fc',
	    'fd',
	    'fe',
	    'ff'
	];
	let _seed = 1234567;
	const DEG2RAD = Math.PI / 180;
	const RAD2DEG = 180 / Math.PI;
	/**
	 * Generate a [UUID]{@link https://en.wikipedia.org/wiki/Universally_unique_identifier}
	 * (universally unique identifier).
	 *
	 * @return {string} The UUID.
	 */ function generateUUID() {
	    // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
	    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];
	    // .toLowerCase() here flattens concatenated strings to save heap memory space.
	    return uuid.toLowerCase();
	}
	/**
	 * Clamps the given value between min and max.
	 *
	 * @param {number} value - The value to clamp.
	 * @param {number} min - The min value.
	 * @param {number} max - The max value.
	 * @return {number} The clamped value.
	 */ function clamp$1(value, min, max) {
	    return Math.max(min, Math.min(max, value));
	}
	/**
	 * Computes the Euclidean modulo of the given parameters that
	 * is `( ( n % m ) + m ) % m`.
	 *
	 * @param {number} n - The first parameter.
	 * @param {number} m - The second parameter.
	 * @return {number} The Euclidean modulo.
	 */ function euclideanModulo(n, m) {
	    // https://en.wikipedia.org/wiki/Modulo_operation
	    return (n % m + m) % m;
	}
	/**
	 * Performs a linear mapping from range `<a1, a2>` to range `<b1, b2>`
	 * for the given value.
	 *
	 * @param {number} x - The value to be mapped.
	 * @param {number} a1 - Minimum value for range A.
	 * @param {number} a2 - Maximum value for range A.
	 * @param {number} b1 - Minimum value for range B.
	 * @param {number} b2 - Maximum value for range B.
	 * @return {number} The mapped value.
	 */ function mapLinear(x, a1, a2, b1, b2) {
	    return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
	}
	/**
	 * Returns the percentage in the closed interval `[0, 1]` of the given value
	 * between the start and end point.
	 *
	 * @param {number} x - The start point
	 * @param {number} y - The end point.
	 * @param {number} value - A value between start and end.
	 * @return {number} The interpolation factor.
	 */ function inverseLerp(x, y, value) {
	    // https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
	    if (x !== y) {
	        return (value - x) / (y - x);
	    } else {
	        return 0;
	    }
	}
	/**
	 * Returns a value linearly interpolated from two known points based on the given interval -
	 * `t = 0` will return `x` and `t = 1` will return `y`.
	 *
	 * @param {number} x - The start point
	 * @param {number} y - The end point.
	 * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
	 * @return {number} The interpolated value.
	 */ function lerp$1(x, y, t) {
	    return (1 - t) * x + t * y;
	}
	/**
	 * Smoothly interpolate a number from `x` to `y` in  a spring-like manner using a delta
	 * time to maintain frame rate independent movement. For details, see
	 * [Frame rate independent damping using lerp]{@link http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/}.
	 *
	 * @param {number} x - The current point.
	 * @param {number} y - The target point.
	 * @param {number} lambda - A higher lambda value will make the movement more sudden,
	 * and a lower value will make the movement more gradual.
	 * @param {number} dt - Delta time in seconds.
	 * @return {number} The interpolated value.
	 */ function damp(x, y, lambda, dt) {
	    return lerp$1(x, y, 1 - Math.exp(-lambda * dt));
	}
	/**
	 * Returns a value that alternates between `0` and the given `length` parameter.
	 *
	 * @param {number} x - The value to pingpong.
	 * @param {number} [length=1] - The positive value the function will pingpong to.
	 * @return {number} The alternated value.
	 */ function pingpong(x, length = 1) {
	    // https://www.desmos.com/calculator/vcsjnyz7x4
	    return length - Math.abs(euclideanModulo(x, length * 2) - length);
	}
	/**
	 * Returns a value in the range `[0,1]` that represents the percentage that `x` has
	 * moved between `min` and `max`, but smoothed or slowed down the closer `x` is to
	 * the `min` and `max`.
	 *
	 * See [Smoothstep]{@link http://en.wikipedia.org/wiki/Smoothstep} for more details.
	 *
	 * @param {number} x - The value to evaluate based on its position between min and max.
	 * @param {number} min - The min value. Any x value below min will be `0`.
	 * @param {number} max - The max value. Any x value above max will be `1`.
	 * @return {number} The alternated value.
	 */ function smoothstep(x, min, max) {
	    if (x <= min) return 0;
	    if (x >= max) return 1;
	    x = (x - min) / (max - min);
	    return x * x * (3 - 2 * x);
	}
	/**
	 * A [variation on smoothstep]{@link https://en.wikipedia.org/wiki/Smoothstep#Variations}
	 * that has zero 1st and 2nd order derivatives at x=0 and x=1.
	 *
	 * @param {number} x - The value to evaluate based on its position between min and max.
	 * @param {number} min - The min value. Any x value below min will be `0`.
	 * @param {number} max - The max value. Any x value above max will be `1`.
	 * @return {number} The alternated value.
	 */ function smootherstep(x, min, max) {
	    if (x <= min) return 0;
	    if (x >= max) return 1;
	    x = (x - min) / (max - min);
	    return x * x * x * (x * (x * 6 - 15) + 10);
	}
	/**
	 * Returns a random integer from `<low, high>` interval.
	 *
	 * @param {number} low - The lower value boundary.
	 * @param {number} high - The upper value boundary
	 * @return {number} A random integer.
	 */ function randInt(low, high) {
	    return low + Math.floor(Math.random() * (high - low + 1));
	}
	/**
	 * Returns a random float from `<low, high>` interval.
	 *
	 * @param {number} low - The lower value boundary.
	 * @param {number} high - The upper value boundary
	 * @return {number} A random float.
	 */ function randFloat(low, high) {
	    return low + Math.random() * (high - low);
	}
	/**
	 * Returns a random integer from `<-range/2, range/2>` interval.
	 *
	 * @param {number} range - Defines the value range.
	 * @return {number} A random float.
	 */ function randFloatSpread(range) {
	    return range * (0.5 - Math.random());
	}
	/**
	 * Returns a deterministic pseudo-random float in the interval `[0, 1]`.
	 *
	 * @param {number} [s] - The integer seed.
	 * @return {number} A random float.
	 */ function seededRandom(s) {
	    if (s !== undefined) _seed = s;
	    // Mulberry32 generator
	    let t = _seed += 0x6D2B79F5;
	    t = Math.imul(t ^ t >>> 15, t | 1);
	    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
	    return ((t ^ t >>> 14) >>> 0) / 4294967296;
	}
	/**
	 * Converts degrees to radians.
	 *
	 * @param {number} degrees - A value in degrees.
	 * @return {number} The converted value in radians.
	 */ function degToRad(degrees) {
	    return degrees * DEG2RAD;
	}
	/**
	 * Converts radians to degrees.
	 *
	 * @param {number} radians - A value in radians.
	 * @return {number} The converted value in degrees.
	 */ function radToDeg(radians) {
	    return radians * RAD2DEG;
	}
	/**
	 * Returns `true` if the given number is a power of two.
	 *
	 * @param {number} value - The value to check.
	 * @return {boolean} Whether the given number is a power of two or not.
	 */ function isPowerOfTwo(value) {
	    return (value & value - 1) === 0 && value !== 0;
	}
	/**
	 * Returns the smallest power of two that is greater than or equal to the given number.
	 *
	 * @param {number} value - The value to find a POT for.
	 * @return {number} The smallest power of two that is greater than or equal to the given number.
	 */ function ceilPowerOfTwo(value) {
	    return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2));
	}
	/**
	 * Returns the largest power of two that is less than or equal to the given number.
	 *
	 * @param {number} value - The value to find a POT for.
	 * @return {number} The largest power of two that is less than or equal to the given number.
	 */ function floorPowerOfTwo(value) {
	    return Math.pow(2, Math.floor(Math.log(value) / Math.LN2));
	}
	/**
	 * Sets the given quaternion from the [Intrinsic Proper Euler Angles]{@link https://en.wikipedia.org/wiki/Euler_angles}
	 * defined by the given angles and order.
	 *
	 * Rotations are applied to the axes in the order specified by order:
	 * rotation by angle `a` is applied first, then by angle `b`, then by angle `c`.
	 *
	 * @param {Quaternion} q - The quaternion to set.
	 * @param {number} a - The rotation applied to the first axis, in radians.
	 * @param {number} b - The rotation applied to the second axis, in radians.
	 * @param {number} c - The rotation applied to the third axis, in radians.
	 * @param {('XYX'|'XZX'|'YXY'|'YZY'|'ZXZ'|'ZYZ')} order - A string specifying the axes order.
	 */ function setQuaternionFromProperEuler(q, a, b, c, order) {
	    const cos = Math.cos;
	    const sin = Math.sin;
	    const c2 = cos(b / 2);
	    const s2 = sin(b / 2);
	    const c13 = cos((a + c) / 2);
	    const s13 = sin((a + c) / 2);
	    const c1_3 = cos((a - c) / 2);
	    const s1_3 = sin((a - c) / 2);
	    const c3_1 = cos((c - a) / 2);
	    const s3_1 = sin((c - a) / 2);
	    switch(order){
	        case 'XYX':
	            q.set(c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13);
	            break;
	        case 'YZY':
	            q.set(s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13);
	            break;
	        case 'ZXZ':
	            q.set(s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13);
	            break;
	        case 'XZX':
	            q.set(c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13);
	            break;
	        case 'YXY':
	            q.set(s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13);
	            break;
	        case 'ZYZ':
	            q.set(s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13);
	            break;
	        default:
	            console.warn('THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order);
	    }
	}
	/**
	 * Denormalizes the given value according to the given typed array.
	 *
	 * @param {number} value - The value to denormalize.
	 * @param {TypedArray} array - The typed array that defines the data type of the value.
	 * @return {number} The denormalize (float) value in the range `[0,1]`.
	 */ function denormalize(value, array) {
	    switch(array.constructor){
	        case Float32Array:
	            return value;
	        case Uint32Array:
	            return value / 4294967295.0;
	        case Uint16Array:
	            return value / 65535.0;
	        case Uint8Array:
	            return value / 255.0;
	        case Int32Array:
	            return Math.max(value / 2147483647.0, -1);
	        case Int16Array:
	            return Math.max(value / 32767.0, -1);
	        case Int8Array:
	            return Math.max(value / 127.0, -1);
	        default:
	            throw new Error('Invalid component type.');
	    }
	}
	/**
	 * Normalizes the given value according to the given typed array.
	 *
	 * @param {number} value - The float value in the range `[0,1]` to normalize.
	 * @param {TypedArray} array - The typed array that defines the data type of the value.
	 * @return {number} The normalize value.
	 */ function normalize(value, array) {
	    switch(array.constructor){
	        case Float32Array:
	            return value;
	        case Uint32Array:
	            return Math.round(value * 4294967295.0);
	        case Uint16Array:
	            return Math.round(value * 65535.0);
	        case Uint8Array:
	            return Math.round(value * 255.0);
	        case Int32Array:
	            return Math.round(value * 2147483647.0);
	        case Int16Array:
	            return Math.round(value * 32767.0);
	        case Int8Array:
	            return Math.round(value * 127.0);
	        default:
	            throw new Error('Invalid component type.');
	    }
	}
	const MathUtils = {
	    DEG2RAD: DEG2RAD,
	    RAD2DEG: RAD2DEG,
	    generateUUID: generateUUID,
	    clamp: clamp$1,
	    euclideanModulo: euclideanModulo,
	    mapLinear: mapLinear,
	    inverseLerp: inverseLerp,
	    lerp: lerp$1,
	    damp: damp,
	    pingpong: pingpong,
	    smoothstep: smoothstep,
	    smootherstep: smootherstep,
	    randInt: randInt,
	    randFloat: randFloat,
	    randFloatSpread: randFloatSpread,
	    seededRandom: seededRandom,
	    degToRad: degToRad,
	    radToDeg: radToDeg,
	    isPowerOfTwo: isPowerOfTwo,
	    ceilPowerOfTwo: ceilPowerOfTwo,
	    floorPowerOfTwo: floorPowerOfTwo,
	    setQuaternionFromProperEuler: setQuaternionFromProperEuler,
	    normalize: normalize,
	    denormalize: denormalize
	};
	/**
	 * Class representing a 2D vector. A 2D vector is an ordered pair of numbers
	 * (labeled x and y), which can be used to represent a number of things, such as:
	 *
	 * - A point in 2D space (i.e. a position on a plane).
	 * - A direction and length across a plane. In three.js the length will
	 * always be the Euclidean distance(straight-line distance) from `(0, 0)` to `(x, y)`
	 * and the direction is also measured from `(0, 0)` towards `(x, y)`.
	 * - Any arbitrary ordered pair of numbers.
	 *
	 * There are other things a 2D vector can be used to represent, such as
	 * momentum vectors, complex numbers and so on, however these are the most
	 * common uses in three.js.
	 *
	 * Iterating through a vector instance will yield its components `(x, y)` in
	 * the corresponding order.
	 * ```js
	 * const a = new THREE.Vector2( 0, 1 );
	 *
	 * //no arguments; will be initialised to (0, 0)
	 * const b = new THREE.Vector2( );
	 *
	 * const d = a.distanceTo( b );
	 * ```
	 */ class Vector2 {
	    /**
		 * Alias for {@link Vector2#x}.
		 *
		 * @type {number}
		 */ get width() {
	        return this.x;
	    }
	    set width(value) {
	        this.x = value;
	    }
	    /**
		 * Alias for {@link Vector2#y}.
		 *
		 * @type {number}
		 */ get height() {
	        return this.y;
	    }
	    set height(value) {
	        this.y = value;
	    }
	    /**
		 * Sets the vector components.
		 *
		 * @param {number} x - The value of the x component.
		 * @param {number} y - The value of the y component.
		 * @return {Vector2} A reference to this vector.
		 */ set(x, y) {
	        this.x = x;
	        this.y = y;
	        return this;
	    }
	    /**
		 * Sets the vector components to the same value.
		 *
		 * @param {number} scalar - The value to set for all vector components.
		 * @return {Vector2} A reference to this vector.
		 */ setScalar(scalar) {
	        this.x = scalar;
	        this.y = scalar;
	        return this;
	    }
	    /**
		 * Sets the vector's x component to the given value
		 *
		 * @param {number} x - The value to set.
		 * @return {Vector2} A reference to this vector.
		 */ setX(x) {
	        this.x = x;
	        return this;
	    }
	    /**
		 * Sets the vector's y component to the given value
		 *
		 * @param {number} y - The value to set.
		 * @return {Vector2} A reference to this vector.
		 */ setY(y) {
	        this.y = y;
	        return this;
	    }
	    /**
		 * Allows to set a vector component with an index.
		 *
		 * @param {number} index - The component index. `0` equals to x, `1` equals to y.
		 * @param {number} value - The value to set.
		 * @return {Vector2} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Returns the value of the vector component which matches the given index.
		 *
		 * @param {number} index - The component index. `0` equals to x, `1` equals to y.
		 * @return {number} A vector component value.
		 */ getComponent(index) {
	        switch(index){
	            case 0:
	                return this.x;
	            case 1:
	                return this.y;
	            default:
	                throw new Error('index is out of range: ' + index);
	        }
	    }
	    /**
		 * Returns a new vector with copied values from this instance.
		 *
		 * @return {Vector2} A clone of this instance.
		 */ clone() {
	        return new this.constructor(this.x, this.y);
	    }
	    /**
		 * Copies the values of the given vector to this instance.
		 *
		 * @param {Vector2} v - The vector to copy.
		 * @return {Vector2} A reference to this vector.
		 */ copy(v) {
	        this.x = v.x;
	        this.y = v.y;
	        return this;
	    }
	    /**
		 * Adds the given vector to this instance.
		 *
		 * @param {Vector2} v - The vector to add.
		 * @return {Vector2} A reference to this vector.
		 */ add(v) {
	        this.x += v.x;
	        this.y += v.y;
	        return this;
	    }
	    /**
		 * Adds the given scalar value to all components of this instance.
		 *
		 * @param {number} s - The scalar to add.
		 * @return {Vector2} A reference to this vector.
		 */ addScalar(s) {
	        this.x += s;
	        this.y += s;
	        return this;
	    }
	    /**
		 * Adds the given vectors and stores the result in this instance.
		 *
		 * @param {Vector2} a - The first vector.
		 * @param {Vector2} b - The second vector.
		 * @return {Vector2} A reference to this vector.
		 */ addVectors(a, b) {
	        this.x = a.x + b.x;
	        this.y = a.y + b.y;
	        return this;
	    }
	    /**
		 * Adds the given vector scaled by the given factor to this instance.
		 *
		 * @param {Vector2} v - The vector.
		 * @param {number} s - The factor that scales `v`.
		 * @return {Vector2} A reference to this vector.
		 */ addScaledVector(v, s) {
	        this.x += v.x * s;
	        this.y += v.y * s;
	        return this;
	    }
	    /**
		 * Subtracts the given vector from this instance.
		 *
		 * @param {Vector2} v - The vector to subtract.
		 * @return {Vector2} A reference to this vector.
		 */ sub(v) {
	        this.x -= v.x;
	        this.y -= v.y;
	        return this;
	    }
	    /**
		 * Subtracts the given scalar value from all components of this instance.
		 *
		 * @param {number} s - The scalar to subtract.
		 * @return {Vector2} A reference to this vector.
		 */ subScalar(s) {
	        this.x -= s;
	        this.y -= s;
	        return this;
	    }
	    /**
		 * Subtracts the given vectors and stores the result in this instance.
		 *
		 * @param {Vector2} a - The first vector.
		 * @param {Vector2} b - The second vector.
		 * @return {Vector2} A reference to this vector.
		 */ subVectors(a, b) {
	        this.x = a.x - b.x;
	        this.y = a.y - b.y;
	        return this;
	    }
	    /**
		 * Multiplies the given vector with this instance.
		 *
		 * @param {Vector2} v - The vector to multiply.
		 * @return {Vector2} A reference to this vector.
		 */ multiply(v) {
	        this.x *= v.x;
	        this.y *= v.y;
	        return this;
	    }
	    /**
		 * Multiplies the given scalar value with all components of this instance.
		 *
		 * @param {number} scalar - The scalar to multiply.
		 * @return {Vector2} A reference to this vector.
		 */ multiplyScalar(scalar) {
	        this.x *= scalar;
	        this.y *= scalar;
	        return this;
	    }
	    /**
		 * Divides this instance by the given vector.
		 *
		 * @param {Vector2} v - The vector to divide.
		 * @return {Vector2} A reference to this vector.
		 */ divide(v) {
	        this.x /= v.x;
	        this.y /= v.y;
	        return this;
	    }
	    /**
		 * Divides this vector by the given scalar.
		 *
		 * @param {number} scalar - The scalar to divide.
		 * @return {Vector2} A reference to this vector.
		 */ divideScalar(scalar) {
	        return this.multiplyScalar(1 / scalar);
	    }
	    /**
		 * Multiplies this vector (with an implicit 1 as the 3rd component) by
		 * the given 3x3 matrix.
		 *
		 * @param {Matrix3} m - The matrix to apply.
		 * @return {Vector2} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * If this vector's x or y value is greater than the given vector's x or y
		 * value, replace that value with the corresponding min value.
		 *
		 * @param {Vector2} v - The vector.
		 * @return {Vector2} A reference to this vector.
		 */ min(v) {
	        this.x = Math.min(this.x, v.x);
	        this.y = Math.min(this.y, v.y);
	        return this;
	    }
	    /**
		 * If this vector's x or y value is less than the given vector's x or y
		 * value, replace that value with the corresponding max value.
		 *
		 * @param {Vector2} v - The vector.
		 * @return {Vector2} A reference to this vector.
		 */ max(v) {
	        this.x = Math.max(this.x, v.x);
	        this.y = Math.max(this.y, v.y);
	        return this;
	    }
	    /**
		 * If this vector's x or y value is greater than the max vector's x or y
		 * value, it is replaced by the corresponding value.
		 * If this vector's x or y value is less than the min vector's x or y value,
		 * it is replaced by the corresponding value.
		 *
		 * @param {Vector2} min - The minimum x and y values.
		 * @param {Vector2} max - The maximum x and y values in the desired range.
		 * @return {Vector2} A reference to this vector.
		 */ clamp(min, max) {
	        // assumes min < max, componentwise
	        this.x = clamp$1(this.x, min.x, max.x);
	        this.y = clamp$1(this.y, min.y, max.y);
	        return this;
	    }
	    /**
		 * If this vector's x or y values are greater than the max value, they are
		 * replaced by the max value.
		 * If this vector's x or y values are less than the min value, they are
		 * replaced by the min value.
		 *
		 * @param {number} minVal - The minimum value the components will be clamped to.
		 * @param {number} maxVal - The maximum value the components will be clamped to.
		 * @return {Vector2} A reference to this vector.
		 */ clampScalar(minVal, maxVal) {
	        this.x = clamp$1(this.x, minVal, maxVal);
	        this.y = clamp$1(this.y, minVal, maxVal);
	        return this;
	    }
	    /**
		 * If this vector's length is greater than the max value, it is replaced by
		 * the max value.
		 * If this vector's length is less than the min value, it is replaced by the
		 * min value.
		 *
		 * @param {number} min - The minimum value the vector length will be clamped to.
		 * @param {number} max - The maximum value the vector length will be clamped to.
		 * @return {Vector2} A reference to this vector.
		 */ clampLength(min, max) {
	        const length = this.length();
	        return this.divideScalar(length || 1).multiplyScalar(clamp$1(length, min, max));
	    }
	    /**
		 * The components of this vector are rounded down to the nearest integer value.
		 *
		 * @return {Vector2} A reference to this vector.
		 */ floor() {
	        this.x = Math.floor(this.x);
	        this.y = Math.floor(this.y);
	        return this;
	    }
	    /**
		 * The components of this vector are rounded up to the nearest integer value.
		 *
		 * @return {Vector2} A reference to this vector.
		 */ ceil() {
	        this.x = Math.ceil(this.x);
	        this.y = Math.ceil(this.y);
	        return this;
	    }
	    /**
		 * The components of this vector are rounded to the nearest integer value
		 *
		 * @return {Vector2} A reference to this vector.
		 */ round() {
	        this.x = Math.round(this.x);
	        this.y = Math.round(this.y);
	        return this;
	    }
	    /**
		 * The components of this vector are rounded towards zero (up if negative,
		 * down if positive) to an integer value.
		 *
		 * @return {Vector2} A reference to this vector.
		 */ roundToZero() {
	        this.x = Math.trunc(this.x);
	        this.y = Math.trunc(this.y);
	        return this;
	    }
	    /**
		 * Inverts this vector - i.e. sets x = -x and y = -y.
		 *
		 * @return {Vector2} A reference to this vector.
		 */ negate() {
	        this.x = -this.x;
	        this.y = -this.y;
	        return this;
	    }
	    /**
		 * Calculates the dot product of the given vector with this instance.
		 *
		 * @param {Vector2} v - The vector to compute the dot product with.
		 * @return {number} The result of the dot product.
		 */ dot(v) {
	        return this.x * v.x + this.y * v.y;
	    }
	    /**
		 * Calculates the cross product of the given vector with this instance.
		 *
		 * @param {Vector2} v - The vector to compute the cross product with.
		 * @return {number} The result of the cross product.
		 */ cross(v) {
	        return this.x * v.y - this.y * v.x;
	    }
	    /**
		 * Computes the square of the Euclidean length (straight-line length) from
		 * (0, 0) to (x, y). If you are comparing the lengths of vectors, you should
		 * compare the length squared instead as it is slightly more efficient to calculate.
		 *
		 * @return {number} The square length of this vector.
		 */ lengthSq() {
	        return this.x * this.x + this.y * this.y;
	    }
	    /**
		 * Computes the  Euclidean length (straight-line length) from (0, 0) to (x, y).
		 *
		 * @return {number} The length of this vector.
		 */ length() {
	        return Math.sqrt(this.x * this.x + this.y * this.y);
	    }
	    /**
		 * Computes the Manhattan length of this vector.
		 *
		 * @return {number} The length of this vector.
		 */ manhattanLength() {
	        return Math.abs(this.x) + Math.abs(this.y);
	    }
	    /**
		 * Converts this vector to a unit vector - that is, sets it equal to a vector
		 * with the same direction as this one, but with a vector length of `1`.
		 *
		 * @return {Vector2} A reference to this vector.
		 */ normalize() {
	        return this.divideScalar(this.length() || 1);
	    }
	    /**
		 * Computes the angle in radians of this vector with respect to the positive x-axis.
		 *
		 * @return {number} The angle in radians.
		 */ angle() {
	        const angle = Math.atan2(-this.y, -this.x) + Math.PI;
	        return angle;
	    }
	    /**
		 * Returns the angle between the given vector and this instance in radians.
		 *
		 * @param {Vector2} v - The vector to compute the angle with.
		 * @return {number} The angle in radians.
		 */ angleTo(v) {
	        const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
	        if (denominator === 0) return Math.PI / 2;
	        const theta = this.dot(v) / denominator;
	        // clamp, to handle numerical problems
	        return Math.acos(clamp$1(theta, -1, 1));
	    }
	    /**
		 * Computes the distance from the given vector to this instance.
		 *
		 * @param {Vector2} v - The vector to compute the distance to.
		 * @return {number} The distance.
		 */ distanceTo(v) {
	        return Math.sqrt(this.distanceToSquared(v));
	    }
	    /**
		 * Computes the squared distance from the given vector to this instance.
		 * If you are just comparing the distance with another distance, you should compare
		 * the distance squared instead as it is slightly more efficient to calculate.
		 *
		 * @param {Vector2} v - The vector to compute the squared distance to.
		 * @return {number} The squared distance.
		 */ distanceToSquared(v) {
	        const dx = this.x - v.x, dy = this.y - v.y;
	        return dx * dx + dy * dy;
	    }
	    /**
		 * Computes the Manhattan distance from the given vector to this instance.
		 *
		 * @param {Vector2} v - The vector to compute the Manhattan distance to.
		 * @return {number} The Manhattan distance.
		 */ manhattanDistanceTo(v) {
	        return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
	    }
	    /**
		 * Sets this vector to a vector with the same direction as this one, but
		 * with the specified length.
		 *
		 * @param {number} length - The new length of this vector.
		 * @return {Vector2} A reference to this vector.
		 */ setLength(length) {
	        return this.normalize().multiplyScalar(length);
	    }
	    /**
		 * Linearly interpolates between the given vector and this instance, where
		 * alpha is the percent distance along the line - alpha = 0 will be this
		 * vector, and alpha = 1 will be the given one.
		 *
		 * @param {Vector2} v - The vector to interpolate towards.
		 * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
		 * @return {Vector2} A reference to this vector.
		 */ lerp(v, alpha) {
	        this.x += (v.x - this.x) * alpha;
	        this.y += (v.y - this.y) * alpha;
	        return this;
	    }
	    /**
		 * Linearly interpolates between the given vectors, where alpha is the percent
		 * distance along the line - alpha = 0 will be first vector, and alpha = 1 will
		 * be the second one. The result is stored in this instance.
		 *
		 * @param {Vector2} v1 - The first vector.
		 * @param {Vector2} v2 - The second vector.
		 * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
		 * @return {Vector2} A reference to this vector.
		 */ lerpVectors(v1, v2, alpha) {
	        this.x = v1.x + (v2.x - v1.x) * alpha;
	        this.y = v1.y + (v2.y - v1.y) * alpha;
	        return this;
	    }
	    /**
		 * Returns `true` if this vector is equal with the given one.
		 *
		 * @param {Vector2} v - The vector to test for equality.
		 * @return {boolean} Whether this vector is equal with the given one.
		 */ equals(v) {
	        return v.x === this.x && v.y === this.y;
	    }
	    /**
		 * Sets this vector's x value to be `array[ offset ]` and y
		 * value to be `array[ offset + 1 ]`.
		 *
		 * @param {Array<number>} array - An array holding the vector component values.
		 * @param {number} [offset=0] - The offset into the array.
		 * @return {Vector2} A reference to this vector.
		 */ fromArray(array, offset = 0) {
	        this.x = array[offset];
	        this.y = array[offset + 1];
	        return this;
	    }
	    /**
		 * Writes the components of this vector to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the vector components.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The vector components.
		 */ toArray(array = [], offset = 0) {
	        array[offset] = this.x;
	        array[offset + 1] = this.y;
	        return array;
	    }
	    /**
		 * Sets the components of this vector from the given buffer attribute.
		 *
		 * @param {BufferAttribute} attribute - The buffer attribute holding vector data.
		 * @param {number} index - The index into the attribute.
		 * @return {Vector2} A reference to this vector.
		 */ fromBufferAttribute(attribute, index) {
	        this.x = attribute.getX(index);
	        this.y = attribute.getY(index);
	        return this;
	    }
	    /**
		 * Rotates this vector around the given center by the given angle.
		 *
		 * @param {Vector2} center - The point around which to rotate.
		 * @param {number} angle - The angle to rotate, in radians.
		 * @return {Vector2} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Sets each component of this vector to a pseudo-random value between `0` and
		 * `1`, excluding `1`.
		 *
		 * @return {Vector2} A reference to this vector.
		 */ random() {
	        this.x = Math.random();
	        this.y = Math.random();
	        return this;
	    }
	    *[Symbol.iterator]() {
	        yield this.x;
	        yield this.y;
	    }
	    /**
		 * Constructs a new 2D vector.
		 *
		 * @param {number} [x=0] - The x value of this vector.
		 * @param {number} [y=0] - The y value of this vector.
		 */ constructor(x = 0, y = 0){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ Vector2.prototype.isVector2 = true;
	        /**
			 * The x value of this vector.
			 *
			 * @type {number}
			 */ this.x = x;
	        /**
			 * The y value of this vector.
			 *
			 * @type {number}
			 */ this.y = y;
	    }
	}
	/**
	 * Represents a 3x3 matrix.
	 *
	 * A Note on Row-Major and Column-Major Ordering:
	 *
	 * The constructor and {@link Matrix3#set} method take arguments in
	 * [row-major]{@link https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order}
	 * order, while internally they are stored in the {@link Matrix3#elements} array in column-major order.
	 * This means that calling:
	 * ```js
	 * const m = new THREE.Matrix();
	 * m.set( 11, 12, 13,
	 *        21, 22, 23,
	 *        31, 32, 33 );
	 * ```
	 * will result in the elements array containing:
	 * ```js
	 * m.elements = [ 11, 21, 31,
	 *                12, 22, 32,
	 *                13, 23, 33 ];
	 * ```
	 * and internally all calculations are performed using column-major ordering.
	 * However, as the actual ordering makes no difference mathematically and
	 * most people are used to thinking about matrices in row-major order, the
	 * three.js documentation shows matrices in row-major order. Just bear in
	 * mind that if you are reading the source code, you'll have to take the
	 * transpose of any matrices outlined here to make sense of the calculations.
	 */ class Matrix3 {
	    /**
		 * Sets the elements of the matrix.The arguments are supposed to be
		 * in row-major order.
		 *
		 * @param {number} [n11] - 1-1 matrix element.
		 * @param {number} [n12] - 1-2 matrix element.
		 * @param {number} [n13] - 1-3 matrix element.
		 * @param {number} [n21] - 2-1 matrix element.
		 * @param {number} [n22] - 2-2 matrix element.
		 * @param {number} [n23] - 2-3 matrix element.
		 * @param {number} [n31] - 3-1 matrix element.
		 * @param {number} [n32] - 3-2 matrix element.
		 * @param {number} [n33] - 3-3 matrix element.
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Sets this matrix to the 3x3 identity matrix.
		 *
		 * @return {Matrix3} A reference to this matrix.
		 */ identity() {
	        this.set(1, 0, 0, 0, 1, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Copies the values of the given matrix to this instance.
		 *
		 * @param {Matrix3} m - The matrix to copy.
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Extracts the basis of this matrix into the three axis vectors provided.
		 *
		 * @param {Vector3} xAxis - The basis's x axis.
		 * @param {Vector3} yAxis - The basis's y axis.
		 * @param {Vector3} zAxis - The basis's z axis.
		 * @return {Matrix3} A reference to this matrix.
		 */ extractBasis(xAxis, yAxis, zAxis) {
	        xAxis.setFromMatrix3Column(this, 0);
	        yAxis.setFromMatrix3Column(this, 1);
	        zAxis.setFromMatrix3Column(this, 2);
	        return this;
	    }
	    /**
		 * Set this matrix to the upper 3x3 matrix of the given 4x4 matrix.
		 *
		 * @param {Matrix4} m - The 4x4 matrix.
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Post-multiplies this matrix by the given 3x3 matrix.
		 *
		 * @param {Matrix3} m - The matrix to multiply with.
		 * @return {Matrix3} A reference to this matrix.
		 */ multiply(m) {
	        return this.multiplyMatrices(this, m);
	    }
	    /**
		 * Pre-multiplies this matrix by the given 3x3 matrix.
		 *
		 * @param {Matrix3} m - The matrix to multiply with.
		 * @return {Matrix3} A reference to this matrix.
		 */ premultiply(m) {
	        return this.multiplyMatrices(m, this);
	    }
	    /**
		 * Multiples the given 3x3 matrices and stores the result
		 * in this matrix.
		 *
		 * @param {Matrix3} a - The first matrix.
		 * @param {Matrix3} b - The second matrix.
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Multiplies every component of the matrix by the given scalar.
		 *
		 * @param {number} s - The scalar.
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Computes and returns the determinant of this matrix.
		 *
		 * @return {number} The determinant.
		 */ 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;
	    }
	    /**
		 * Inverts this matrix, using the [analytic method]{@link https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution}.
		 * You can not invert with a determinant of zero. If you attempt this, the method produces
		 * a zero matrix instead.
		 *
		 * @return {Matrix3} A reference to this matrix.
		 */ invert() {
	        const te = this.elements, 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;
	    }
	    /**
		 * Transposes this matrix in place.
		 *
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Computes the normal matrix which is the inverse transpose of the upper
		 * left 3x3 portion of the given 4x4 matrix.
		 *
		 * @param {Matrix4} matrix4 - The 4x4 matrix.
		 * @return {Matrix3} A reference to this matrix.
		 */ getNormalMatrix(matrix4) {
	        return this.setFromMatrix4(matrix4).invert().transpose();
	    }
	    /**
		 * Transposes this matrix into the supplied array, and returns itself unchanged.
		 *
		 * @param {Array<number>} r - An array to store the transposed matrix elements.
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Sets the UV transform matrix from offset, repeat, rotation, and center.
		 *
		 * @param {number} tx - Offset x.
		 * @param {number} ty - Offset y.
		 * @param {number} sx - Repeat x.
		 * @param {number} sy - Repeat y.
		 * @param {number} rotation - Rotation, in radians. Positive values rotate counterclockwise.
		 * @param {number} cx - Center x of rotation.
		 * @param {number} cy - Center y of rotation
		 * @return {Matrix3} A reference to this matrix.
		 */ 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;
	    }
	    /**
		 * Scales this matrix with the given scalar values.
		 *
		 * @param {number} sx - The amount to scale in the X axis.
		 * @param {number} sy - The amount to scale in the Y axis.
		 * @return {Matrix3} A reference to this matrix.
		 */ scale(sx, sy) {
	        this.premultiply(_m3.makeScale(sx, sy));
	        return this;
	    }
	    /**
		 * Rotates this matrix by the given angle.
		 *
		 * @param {number} theta - The rotation in radians.
		 * @return {Matrix3} A reference to this matrix.
		 */ rotate(theta) {
	        this.premultiply(_m3.makeRotation(-theta));
	        return this;
	    }
	    /**
		 * Translates this matrix by the given scalar values.
		 *
		 * @param {number} tx - The amount to translate in the X axis.
		 * @param {number} ty - The amount to translate in the Y axis.
		 * @return {Matrix3} A reference to this matrix.
		 */ translate(tx, ty) {
	        this.premultiply(_m3.makeTranslation(tx, ty));
	        return this;
	    }
	    // for 2D Transforms
	    /**
		 * Sets this matrix as a 2D translation transform.
		 *
		 * @param {number|Vector2} x - The amount to translate in the X axis or alternatively a translation vector.
		 * @param {number} y - The amount to translate in the Y axis.
		 * @return {Matrix3} A reference to this matrix.
		 */ makeTranslation(x, y) {
	        if (x.isVector2) {
	            this.set(1, 0, x.x, 0, 1, x.y, 0, 0, 1);
	        } else {
	            this.set(1, 0, x, 0, 1, y, 0, 0, 1);
	        }
	        return this;
	    }
	    /**
		 * Sets this matrix as a 2D rotational transformation.
		 *
		 * @param {number} theta - The rotation in radians.
		 * @return {Matrix3} A reference to this matrix.
		 */ makeRotation(theta) {
	        // counterclockwise
	        const c = Math.cos(theta);
	        const s = Math.sin(theta);
	        this.set(c, -s, 0, s, c, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix as a 2D scale transform.
		 *
		 * @param {number} x - The amount to scale in the X axis.
		 * @param {number} y - The amount to scale in the Y axis.
		 * @return {Matrix3} A reference to this matrix.
		 */ makeScale(x, y) {
	        this.set(x, 0, 0, 0, y, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Returns `true` if this matrix is equal with the given one.
		 *
		 * @param {Matrix3} matrix - The matrix to test for equality.
		 * @return {boolean} Whether this matrix is equal with the given one.
		 */ 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;
	    }
	    /**
		 * Sets the elements of the matrix from the given array.
		 *
		 * @param {Array<number>} array - The matrix elements in column-major order.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Matrix3} A reference to this matrix.
		 */ fromArray(array, offset = 0) {
	        for(let i = 0; i < 9; i++){
	            this.elements[i] = array[i + offset];
	        }
	        return this;
	    }
	    /**
		 * Writes the elements of this matrix to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the matrix elements in column-major order.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The matrix elements in column-major order.
		 */ 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;
	    }
	    /**
		 * Returns a matrix with copied values from this instance.
		 *
		 * @return {Matrix3} A clone of this instance.
		 */ clone() {
	        return new this.constructor().fromArray(this.elements);
	    }
	    /**
		 * Constructs a new 3x3 matrix. The arguments are supposed to be
		 * in row-major order. If no arguments are provided, the constructor
		 * initializes the matrix as an identity matrix.
		 *
		 * @param {number} [n11] - 1-1 matrix element.
		 * @param {number} [n12] - 1-2 matrix element.
		 * @param {number} [n13] - 1-3 matrix element.
		 * @param {number} [n21] - 2-1 matrix element.
		 * @param {number} [n22] - 2-2 matrix element.
		 * @param {number} [n23] - 2-3 matrix element.
		 * @param {number} [n31] - 3-1 matrix element.
		 * @param {number} [n32] - 3-2 matrix element.
		 * @param {number} [n33] - 3-3 matrix element.
		 */ constructor(n11, n12, n13, n21, n22, n23, n31, n32, n33){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ Matrix3.prototype.isMatrix3 = true;
	        /**
			 * A column-major list of matrix values.
			 *
			 * @type {Array<number>}
			 */ this.elements = [
	            1,
	            0,
	            0,
	            0,
	            1,
	            0,
	            0,
	            0,
	            1
	        ];
	        if (n11 !== undefined) {
	            this.set(n11, n12, n13, n21, n22, n23, n31, n32, n33);
	        }
	    }
	}
	const _m3 = /*@__PURE__*/ new Matrix3();
	function arrayNeedsUint32(array) {
	    // assumes larger values usually on last
	    for(let i = array.length - 1; i >= 0; --i){
	        if (array[i] >= 65535) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
	    }
	    return false;
	}
	function createElementNS(name) {
	    return document.createElementNS('http://www.w3.org/1999/xhtml', name);
	}
	function createCanvasElement() {
	    const canvas = createElementNS('canvas');
	    canvas.style.display = 'block';
	    return canvas;
	}
	const _cache = {};
	function warnOnce(message) {
	    if (message in _cache) return;
	    _cache[message] = true;
	    console.warn(message);
	}
	function probeAsync(gl, sync, interval) {
	    return new Promise(function(resolve, reject) {
	        function probe() {
	            switch(gl.clientWaitSync(sync, gl.SYNC_FLUSH_COMMANDS_BIT, 0)){
	                case gl.WAIT_FAILED:
	                    reject();
	                    break;
	                case gl.TIMEOUT_EXPIRED:
	                    setTimeout(probe, interval);
	                    break;
	                default:
	                    resolve();
	            }
	        }
	        setTimeout(probe, interval);
	    });
	}
	function toNormalizedProjectionMatrix(projectionMatrix) {
	    const m = projectionMatrix.elements;
	    // Convert [-1, 1] to [0, 1] projection matrix
	    m[2] = 0.5 * m[2] + 0.5 * m[3];
	    m[6] = 0.5 * m[6] + 0.5 * m[7];
	    m[10] = 0.5 * m[10] + 0.5 * m[11];
	    m[14] = 0.5 * m[14] + 0.5 * m[15];
	}
	function toReversedProjectionMatrix(projectionMatrix) {
	    const m = projectionMatrix.elements;
	    const isPerspectiveMatrix = m[11] === -1;
	    // Reverse [0, 1] projection matrix
	    if (isPerspectiveMatrix) {
	        m[10] = -m[10] - 1;
	        m[14] = -m[14];
	    } else {
	        m[10] = -m[10];
	        m[14] = -m[14] + 1;
	    }
	}
	const LINEAR_REC709_TO_XYZ = /*@__PURE__*/ new Matrix3().set(0.4123908, 0.3575843, 0.1804808, 0.2126390, 0.7151687, 0.0721923, 0.0193308, 0.1191948, 0.9505322);
	const XYZ_TO_LINEAR_REC709 = /*@__PURE__*/ new Matrix3().set(3.2409699, -1.5373832, -0.4986108, -0.9692436, 1.8759675, 0.0415551, 0.0556301, -0.203977, 1.0569715);
	function createColorManagement() {
	    const ColorManagement = {
	        enabled: true,
	        workingColorSpace: LinearSRGBColorSpace,
	        /**
			 * Implementations of supported color spaces.
			 *
			 * Required:
			 *	- primaries: chromaticity coordinates [ rx ry gx gy bx by ]
			 *	- whitePoint: reference white [ x y ]
			 *	- transfer: transfer function (pre-defined)
			 *	- toXYZ: Matrix3 RGB to XYZ transform
			 *	- fromXYZ: Matrix3 XYZ to RGB transform
			 *	- luminanceCoefficients: RGB luminance coefficients
			 *
			 * Optional:
			 *  - outputColorSpaceConfig: { drawingBufferColorSpace: ColorSpace }
			 *  - workingColorSpaceConfig: { unpackColorSpace: ColorSpace }
			 *
			 * Reference:
			 * - https://www.russellcottrell.com/photo/matrixCalculator.htm
			 */ spaces: {},
	        convert: function(color, sourceColorSpace, targetColorSpace) {
	            if (this.enabled === false || sourceColorSpace === targetColorSpace || !sourceColorSpace || !targetColorSpace) {
	                return color;
	            }
	            if (this.spaces[sourceColorSpace].transfer === SRGBTransfer) {
	                color.r = SRGBToLinear(color.r);
	                color.g = SRGBToLinear(color.g);
	                color.b = SRGBToLinear(color.b);
	            }
	            if (this.spaces[sourceColorSpace].primaries !== this.spaces[targetColorSpace].primaries) {
	                color.applyMatrix3(this.spaces[sourceColorSpace].toXYZ);
	                color.applyMatrix3(this.spaces[targetColorSpace].fromXYZ);
	            }
	            if (this.spaces[targetColorSpace].transfer === SRGBTransfer) {
	                color.r = LinearToSRGB(color.r);
	                color.g = LinearToSRGB(color.g);
	                color.b = LinearToSRGB(color.b);
	            }
	            return color;
	        },
	        fromWorkingColorSpace: function(color, targetColorSpace) {
	            return this.convert(color, this.workingColorSpace, targetColorSpace);
	        },
	        toWorkingColorSpace: function(color, sourceColorSpace) {
	            return this.convert(color, sourceColorSpace, this.workingColorSpace);
	        },
	        getPrimaries: function(colorSpace) {
	            return this.spaces[colorSpace].primaries;
	        },
	        getTransfer: function(colorSpace) {
	            if (colorSpace === NoColorSpace) return LinearTransfer;
	            return this.spaces[colorSpace].transfer;
	        },
	        getLuminanceCoefficients: function(target, colorSpace = this.workingColorSpace) {
	            return target.fromArray(this.spaces[colorSpace].luminanceCoefficients);
	        },
	        define: function(colorSpaces) {
	            Object.assign(this.spaces, colorSpaces);
	        },
	        // Internal APIs
	        _getMatrix: function(targetMatrix, sourceColorSpace, targetColorSpace) {
	            return targetMatrix.copy(this.spaces[sourceColorSpace].toXYZ).multiply(this.spaces[targetColorSpace].fromXYZ);
	        },
	        _getDrawingBufferColorSpace: function(colorSpace) {
	            return this.spaces[colorSpace].outputColorSpaceConfig.drawingBufferColorSpace;
	        },
	        _getUnpackColorSpace: function(colorSpace = this.workingColorSpace) {
	            return this.spaces[colorSpace].workingColorSpaceConfig.unpackColorSpace;
	        }
	    };
	    /******************************************************************************
		 * sRGB definitions
		 */ const REC709_PRIMARIES = [
	        0.640,
	        0.330,
	        0.300,
	        0.600,
	        0.150,
	        0.060
	    ];
	    const REC709_LUMINANCE_COEFFICIENTS = [
	        0.2126,
	        0.7152,
	        0.0722
	    ];
	    const D65 = [
	        0.3127,
	        0.3290
	    ];
	    ColorManagement.define({
	        [LinearSRGBColorSpace]: {
	            primaries: REC709_PRIMARIES,
	            whitePoint: D65,
	            transfer: LinearTransfer,
	            toXYZ: LINEAR_REC709_TO_XYZ,
	            fromXYZ: XYZ_TO_LINEAR_REC709,
	            luminanceCoefficients: REC709_LUMINANCE_COEFFICIENTS,
	            workingColorSpaceConfig: {
	                unpackColorSpace: SRGBColorSpace
	            },
	            outputColorSpaceConfig: {
	                drawingBufferColorSpace: SRGBColorSpace
	            }
	        },
	        [SRGBColorSpace]: {
	            primaries: REC709_PRIMARIES,
	            whitePoint: D65,
	            transfer: SRGBTransfer,
	            toXYZ: LINEAR_REC709_TO_XYZ,
	            fromXYZ: XYZ_TO_LINEAR_REC709,
	            luminanceCoefficients: REC709_LUMINANCE_COEFFICIENTS,
	            outputColorSpaceConfig: {
	                drawingBufferColorSpace: SRGBColorSpace
	            }
	        }
	    });
	    return ColorManagement;
	}
	const ColorManagement = /*@__PURE__*/ createColorManagement();
	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;
	}
	let _canvas;
	/**
	 * A class containing utility functions for images.
	 *
	 * @hideconstructor
	 */ class ImageUtils {
	    /**
		 * Returns a data URI containing a representation of the given image.
		 *
		 * @param {(HTMLImageElement|HTMLCanvasElement)} image - The image object.
		 * @return {string} The data URI.
		 */ static getDataURL(image) {
	        if (/^data:/i.test(image.src)) {
	            return image.src;
	        }
	        if (typeof HTMLCanvasElement === 'undefined') {
	            return image.src;
	        }
	        let canvas;
	        if (image instanceof HTMLCanvasElement) {
	            canvas = image;
	        } else {
	            if (_canvas === undefined) _canvas = createElementNS('canvas');
	            _canvas.width = image.width;
	            _canvas.height = image.height;
	            const context = _canvas.getContext('2d');
	            if (image instanceof ImageData) {
	                context.putImageData(image, 0, 0);
	            } else {
	                context.drawImage(image, 0, 0, image.width, image.height);
	            }
	            canvas = _canvas;
	        }
	        return canvas.toDataURL('image/png');
	    }
	    /**
		 * Converts the given sRGB image data to linear color space.
		 *
		 * @param {(HTMLImageElement|HTMLCanvasElement|ImageBitmap|Object)} image - The image object.
		 * @return {HTMLCanvasElement|Object} The converted image.
		 */ static sRGBToLinear(image) {
	        if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
	            const canvas = createElementNS('canvas');
	            canvas.width = image.width;
	            canvas.height = image.height;
	            const context = canvas.getContext('2d');
	            context.drawImage(image, 0, 0, image.width, image.height);
	            const imageData = context.getImageData(0, 0, image.width, image.height);
	            const data = imageData.data;
	            for(let i = 0; i < data.length; i++){
	                data[i] = SRGBToLinear(data[i] / 255) * 255;
	            }
	            context.putImageData(imageData, 0, 0);
	            return canvas;
	        } else if (image.data) {
	            const data = image.data.slice(0);
	            for(let i = 0; i < data.length; i++){
	                if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
	                    data[i] = Math.floor(SRGBToLinear(data[i] / 255) * 255);
	                } else {
	                    // assuming float
	                    data[i] = SRGBToLinear(data[i]);
	                }
	            }
	            return {
	                data: data,
	                width: image.width,
	                height: image.height
	            };
	        } else {
	            console.warn('THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.');
	            return image;
	        }
	    }
	}
	let _sourceId = 0;
	class Source {
	    set needsUpdate(value) {
	        if (value === true) this.version++;
	    }
	    toJSON(meta) {
	        const isRootObject = meta === undefined || typeof meta === 'string';
	        if (!isRootObject && meta.images[this.uuid] !== undefined) {
	            return meta.images[this.uuid];
	        }
	        const output = {
	            uuid: this.uuid,
	            url: ''
	        };
	        const data = this.data;
	        if (data !== null) {
	            let url;
	            if (Array.isArray(data)) {
	                // cube texture
	                url = [];
	                for(let i = 0, l = data.length; i < l; i++){
	                    if (data[i].isDataTexture) {
	                        url.push(serializeImage(data[i].image));
	                    } else {
	                        url.push(serializeImage(data[i]));
	                    }
	                }
	            } else {
	                // texture
	                url = serializeImage(data);
	            }
	            output.url = url;
	        }
	        if (!isRootObject) {
	            meta.images[this.uuid] = output;
	        }
	        return output;
	    }
	    constructor(data = null){
	        this.isSource = true;
	        Object.defineProperty(this, 'id', {
	            value: _sourceId++
	        });
	        this.uuid = generateUUID();
	        this.data = data;
	        this.dataReady = true;
	        this.version = 0;
	    }
	}
	function serializeImage(image) {
	    if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
	        // default images
	        return ImageUtils.getDataURL(image);
	    } else {
	        if (image.data) {
	            // images of DataTexture
	            return {
	                data: Array.from(image.data),
	                width: image.width,
	                height: image.height,
	                type: image.data.constructor.name
	            };
	        } else {
	            console.warn('THREE.Texture: Unable to serialize Texture.');
	            return {};
	        }
	    }
	}
	let _textureId = 0;
	/**
	 * Base class for all textures.
	 *
	 * Note: After the initial use of a texture, its dimensions, format, and type
	 * cannot be changed. Instead, call {@link Texture#dispose} on the texture and instantiate a new one.
	 *
	 * @augments EventDispatcher
	 */ let Texture$1 = class Texture extends EventDispatcher {
	    /**
		 * The image object holding the texture data.
		 *
		 * @type {?Object}
		 */ get image() {
	        return this.source.data;
	    }
	    set image(value = null) {
	        this.source.data = value;
	    }
	    /**
		 * Updates the texture transformation matrix from the from the properties {@link Texture#offset},
		 * {@link Texture#repeat}, {@link Texture#rotation}, and {@link Texture#center}.
		 */ updateMatrix() {
	        this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y);
	    }
	    /**
		 * Returns a new texture with copied values from this instance.
		 *
		 * @return {Texture} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Copies the values of the given texture to this instance.
		 *
		 * @param {Texture} source - The texture to copy.
		 * @return {Texture} A reference to this instance.
		 */ copy(source) {
	        this.name = source.name;
	        this.source = source.source;
	        this.mipmaps = source.mipmaps.slice(0);
	        this.mapping = source.mapping;
	        this.channel = source.channel;
	        this.wrapS = source.wrapS;
	        this.wrapT = source.wrapT;
	        this.magFilter = source.magFilter;
	        this.minFilter = source.minFilter;
	        this.anisotropy = source.anisotropy;
	        this.format = source.format;
	        this.internalFormat = source.internalFormat;
	        this.type = source.type;
	        this.offset.copy(source.offset);
	        this.repeat.copy(source.repeat);
	        this.center.copy(source.center);
	        this.rotation = source.rotation;
	        this.matrixAutoUpdate = source.matrixAutoUpdate;
	        this.matrix.copy(source.matrix);
	        this.generateMipmaps = source.generateMipmaps;
	        this.premultiplyAlpha = source.premultiplyAlpha;
	        this.flipY = source.flipY;
	        this.unpackAlignment = source.unpackAlignment;
	        this.colorSpace = source.colorSpace;
	        this.renderTarget = source.renderTarget;
	        this.isRenderTargetTexture = source.isRenderTargetTexture;
	        this.userData = JSON.parse(JSON.stringify(source.userData));
	        this.needsUpdate = true;
	        return this;
	    }
	    /**
		 * Serializes the texture into JSON.
		 *
		 * @param {?(Object|string)} meta - An optional value holding meta information about the serialization.
		 * @return {Object} A JSON object representing the serialized texture.
		 * @see {@link ObjectLoader#parse}
		 */ toJSON(meta) {
	        const isRootObject = meta === undefined || typeof meta === 'string';
	        if (!isRootObject && meta.textures[this.uuid] !== undefined) {
	            return meta.textures[this.uuid];
	        }
	        const output = {
	            metadata: {
	                version: 4.6,
	                type: 'Texture',
	                generator: 'Texture.toJSON'
	            },
	            uuid: this.uuid,
	            name: this.name,
	            image: this.source.toJSON(meta).uuid,
	            mapping: this.mapping,
	            channel: this.channel,
	            repeat: [
	                this.repeat.x,
	                this.repeat.y
	            ],
	            offset: [
	                this.offset.x,
	                this.offset.y
	            ],
	            center: [
	                this.center.x,
	                this.center.y
	            ],
	            rotation: this.rotation,
	            wrap: [
	                this.wrapS,
	                this.wrapT
	            ],
	            format: this.format,
	            internalFormat: this.internalFormat,
	            type: this.type,
	            colorSpace: this.colorSpace,
	            minFilter: this.minFilter,
	            magFilter: this.magFilter,
	            anisotropy: this.anisotropy,
	            flipY: this.flipY,
	            generateMipmaps: this.generateMipmaps,
	            premultiplyAlpha: this.premultiplyAlpha,
	            unpackAlignment: this.unpackAlignment
	        };
	        if (Object.keys(this.userData).length > 0) output.userData = this.userData;
	        if (!isRootObject) {
	            meta.textures[this.uuid] = output;
	        }
	        return output;
	    }
	    /**
		 * Frees the GPU-related resources allocated by this instance. Call this
		 * method whenever this instance is no longer used in your app.
		 *
		 * @fires Texture#dispose
		 */ dispose() {
	        /**
			 * Fires when the texture has been disposed of.
			 *
			 * @event Texture#dispose
			 * @type {Object}
			 */ this.dispatchEvent({
	            type: 'dispose'
	        });
	    }
	    /**
		 * Transforms the given uv vector with the textures uv transformation matrix.
		 *
		 * @param {Vector2} uv - The uv vector.
		 * @return {Vector2} The transformed uv vector.
		 */ transformUv(uv) {
	        if (this.mapping !== UVMapping) return uv;
	        uv.applyMatrix3(this.matrix);
	        if (uv.x < 0 || uv.x > 1) {
	            switch(this.wrapS){
	                case RepeatWrapping:
	                    uv.x = uv.x - Math.floor(uv.x);
	                    break;
	                case ClampToEdgeWrapping:
	                    uv.x = uv.x < 0 ? 0 : 1;
	                    break;
	                case MirroredRepeatWrapping:
	                    if (Math.abs(Math.floor(uv.x) % 2) === 1) {
	                        uv.x = Math.ceil(uv.x) - uv.x;
	                    } else {
	                        uv.x = uv.x - Math.floor(uv.x);
	                    }
	                    break;
	            }
	        }
	        if (uv.y < 0 || uv.y > 1) {
	            switch(this.wrapT){
	                case RepeatWrapping:
	                    uv.y = uv.y - Math.floor(uv.y);
	                    break;
	                case ClampToEdgeWrapping:
	                    uv.y = uv.y < 0 ? 0 : 1;
	                    break;
	                case MirroredRepeatWrapping:
	                    if (Math.abs(Math.floor(uv.y) % 2) === 1) {
	                        uv.y = Math.ceil(uv.y) - uv.y;
	                    } else {
	                        uv.y = uv.y - Math.floor(uv.y);
	                    }
	                    break;
	            }
	        }
	        if (this.flipY) {
	            uv.y = 1 - uv.y;
	        }
	        return uv;
	    }
	    /**
		 * Setting this property to `true` indicates the engine the texture
		 * must be updated in the next render. This triggers a texture upload
		 * to the GPU and ensures correct texture parameter configuration.
		 *
		 * @type {boolean}
		 * @default false
		 * @param {boolean} value
		 */ set needsUpdate(value) {
	        if (value === true) {
	            this.version++;
	            this.source.needsUpdate = true;
	        }
	    }
	    /**
		 * Setting this property to `true` indicates the engine the PMREM
		 * must be regenerated.
		 *
		 * @type {boolean}
		 * @default false
		 * @param {boolean} value
		 */ set needsPMREMUpdate(value) {
	        if (value === true) {
	            this.pmremVersion++;
	        }
	    }
	    /**
		 * Constructs a new texture.
		 *
		 * @param {?Object} [image=Texture.DEFAULT_IMAGE] - The image holding the texture data.
		 * @param {number} [mapping=Texture.DEFAULT_MAPPING] - The texture mapping.
		 * @param {number} [wrapS=ClampToEdgeWrapping] - The wrapS value.
		 * @param {number} [wrapT=ClampToEdgeWrapping] - The wrapT value.
		 * @param {number} [magFilter=LinearFilter] - The mag filter value.
		 * @param {number} [minFilter=LinearFilter] - The min filter value.
		 * @param {number} [format=RGBAFormat] - The min filter value.
		 * @param {number} [type=UnsignedByteType] - The min filter value.
		 * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The min filter value.
		 * @param {string} [colorSpace=NoColorSpace] - The min filter value.
		 */ constructor(image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isTexture = true;
	        /**
			 * The ID of the texture.
			 *
			 * @name Texture#id
			 * @type {number}
			 * @readonly
			 */ Object.defineProperty(this, 'id', {
	            value: _textureId++
	        });
	        /**
			 * The UUID of the material.
			 *
			 * @type {string}
			 * @readonly
			 */ this.uuid = generateUUID();
	        /**
			 * The name of the material.
			 *
			 * @type {string}
			 */ this.name = '';
	        /**
			 * The data definition of a texture. A reference to the data source can be
			 * shared across textures. This is often useful in context of spritesheets
			 * where multiple textures render the same data but with different texture
			 * transformations.
			 *
			 * @type {Source}
			 */ this.source = new Source(image);
	        /**
			 * An array holding user-defined mipmaps.
			 *
			 * @type {Array<Object>}
			 */ this.mipmaps = [];
	        /**
			 * How the texture is applied to the object. The value `UVMapping`
			 * is the default, where texture or uv coordinates are used to apply the map.
			 *
			 * @type {(UVMapping|CubeReflectionMapping|CubeRefractionMapping|EquirectangularReflectionMapping|EquirectangularRefractionMapping|CubeUVReflectionMapping)}
			 * @default UVMapping
			*/ this.mapping = mapping;
	        /**
			 * Lets you select the uv attribute to map the texture to. `0` for `uv`,
			 * `1` for `uv1`, `2` for `uv2` and `3` for `uv3`.
			 *
			 * @type {number}
			 * @default 0
			 */ this.channel = 0;
	        /**
			 * This defines how the texture is wrapped horizontally and corresponds to
			 * *U* in UV mapping.
			 *
			 * @type {(RepeatWrapping|ClampToEdgeWrapping|MirroredRepeatWrapping)}
			 * @default ClampToEdgeWrapping
			 */ this.wrapS = wrapS;
	        /**
			 * This defines how the texture is wrapped horizontally and corresponds to
			 * *V* in UV mapping.
			 *
			 * @type {(RepeatWrapping|ClampToEdgeWrapping|MirroredRepeatWrapping)}
			 * @default ClampToEdgeWrapping
			 */ this.wrapT = wrapT;
	        /**
			 * How the texture is sampled when a texel covers more than one pixel.
			 *
			 * @type {(NearestFilter|NearestMipmapNearestFilter|NearestMipmapLinearFilter|LinearFilter|LinearMipmapNearestFilter|LinearMipmapLinearFilter)}
			 * @default LinearFilter
			 */ this.magFilter = magFilter;
	        /**
			 * How the texture is sampled when a texel covers less than one pixel.
			 *
			 * @type {(NearestFilter|NearestMipmapNearestFilter|NearestMipmapLinearFilter|LinearFilter|LinearMipmapNearestFilter|LinearMipmapLinearFilter)}
			 * @default LinearMipmapLinearFilter
			 */ this.minFilter = minFilter;
	        /**
			 * The number of samples taken along the axis through the pixel that has the
			 * highest density of texels. By default, this value is `1`. A higher value
			 * gives a less blurry result than a basic mipmap, at the cost of more
			 * texture samples being used.
			 *
			 * @type {number}
			 * @default 0
			 */ this.anisotropy = anisotropy;
	        /**
			 * The format of the texture.
			 *
			 * @type {number}
			 * @default RGBAFormat
			 */ this.format = format;
	        /**
			 * The default internal format is derived from {@link Texture#format} and {@link Texture#type} and
			 * defines how the texture data is going to be stored on the GPU.
			 *
			 * This property allows to overwrite the default format.
			 *
			 * @type {?string}
			 * @default null
			 */ this.internalFormat = null;
	        /**
			 * The data type of the texture.
			 *
			 * @type {number}
			 * @default UnsignedByteType
			 */ this.type = type;
	        /**
			 * How much a single repetition of the texture is offset from the beginning,
			 * in each direction U and V. Typical range is `0.0` to `1.0`.
			 *
			 * @type {Vector2}
			 * @default (0,0)
			 */ this.offset = new Vector2(0, 0);
	        /**
			 * How many times the texture is repeated across the surface, in each
			 * direction U and V. If repeat is set greater than `1` in either direction,
			 * the corresponding wrap parameter should also be set to `RepeatWrapping`
			 * or `MirroredRepeatWrapping` to achieve the desired tiling effect.
			 *
			 * @type {Vector2}
			 * @default (1,1)
			 */ this.repeat = new Vector2(1, 1);
	        /**
			 * The point around which rotation occurs. A value of `(0.5, 0.5)` corresponds
			 * to the center of the texture. Default is `(0, 0)`, the lower left.
			 *
			 * @type {Vector2}
			 * @default (0,0)
			 */ this.center = new Vector2(0, 0);
	        /**
			 * How much the texture is rotated around the center point, in radians.
			 * Positive values are counter-clockwise.
			 *
			 * @type {number}
			 * @default 0
			 */ this.rotation = 0;
	        /**
			 * Whether to update the texture's uv-transformation {@link Texture#matrix}
			 * from the properties {@link Texture#offset}, {@link Texture#repeat},
			 * {@link Texture#rotation}, and {@link Texture#center}.
			 *
			 * Set this to `false` if you are specifying the uv-transform matrix directly.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.matrixAutoUpdate = true;
	        /**
			 * The uv-transformation matrix of the texture.
			 *
			 * @type {Matrix3}
			 */ this.matrix = new Matrix3();
	        /**
			 * Whether to generate mipmaps (if possible) for a texture.
			 *
			 * Set this to `false` if you are creating mipmaps manually.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.generateMipmaps = true;
	        /**
			 * If set to `true`, the alpha channel, if present, is multiplied into the
			 * color channels when the texture is uploaded to the GPU.
			 *
			 * Note that this property has no effect when using `ImageBitmap`. You need to
			 * configure premultiply alpha on bitmap creation instead.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.premultiplyAlpha = false;
	        /**
			 * If set to `true`, the texture is flipped along the vertical axis when
			 * uploaded to the GPU.
			 *
			 * Note that this property has no effect when using `ImageBitmap`. You need to
			 * configure the flip on bitmap creation instead.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.flipY = true;
	        /**
			 * Specifies the alignment requirements for the start of each pixel row in memory.
			 * The allowable values are `1` (byte-alignment), `2` (rows aligned to even-numbered bytes),
			 * `4` (word-alignment), and `8` (rows start on double-word boundaries).
			 *
			 * @type {number}
			 * @default 4
			 */ this.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
	        /**
			 * Textures containing color data should be annotated with `SRGBColorSpace` or `LinearSRGBColorSpace`.
			 *
			 * @type {string}
			 * @default NoColorSpace
			 */ this.colorSpace = colorSpace;
	        /**
			 * An object that can be used to store custom data about the texture. It
			 * should not hold references to functions as these will not be cloned.
			 *
			 * @type {Object}
			 */ this.userData = {};
	        /**
			 * This starts at `0` and counts how many times {@link Texture#needsUpdate} is set to `true`.
			 *
			 * @type {number}
			 * @readonly
			 * @default 0
			 */ this.version = 0;
	        /**
			 * A callback function, called when the texture is updated (e.g., when
			 * {@link Texture#needsUpdate} has been set to true and then the texture is used).
			 *
			 * @type {?Function}
			 * @default null
			 */ this.onUpdate = null;
	        /**
			 * An optional back reference to the textures render target.
			 *
			 * @type {?(RenderTarget|WebGLRenderTarget)}
			 * @default null
			 */ this.renderTarget = null;
	        /**
			 * Indicates whether a texture belongs to a render target or not.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default false
			 */ this.isRenderTargetTexture = false;
	        /**
			 * Indicates whether this texture should be processed by `PMREMGenerator` or not
			 * (only relevant for render target textures).
			 *
			 * @type {number}
			 * @readonly
			 * @default 0
			 */ this.pmremVersion = 0;
	    }
	};
	/**
	 * The default image for all textures.
	 *
	 * @static
	 * @type {?Image}
	 * @default null
	 */ Texture$1.DEFAULT_IMAGE = null;
	/**
	 * The default mapping for all textures.
	 *
	 * @static
	 * @type {number}
	 * @default UVMapping
	 */ Texture$1.DEFAULT_MAPPING = UVMapping;
	/**
	 * The default anisotropy value for all textures.
	 *
	 * @static
	 * @type {number}
	 * @default 1
	 */ Texture$1.DEFAULT_ANISOTROPY = 1;
	/**
	 * Class representing a 4D vector. A 4D vector is an ordered quadruplet of numbers
	 * (labeled x, y, z and w), which can be used to represent a number of things, such as:
	 *
	 * - A point in 4D space.
	 * - A direction and length in 4D space. In three.js the length will
	 * always be the Euclidean distance(straight-line distance) from `(0, 0, 0, 0)` to `(x, y, z, w)`
	 * and the direction is also measured from `(0, 0, 0, 0)` towards `(x, y, z, w)`.
	 * - Any arbitrary ordered quadruplet of numbers.
	 *
	 * There are other things a 4D vector can be used to represent, however these
	 * are the most common uses in *three.js*.
	 *
	 * Iterating through a vector instance will yield its components `(x, y, z, w)` in
	 * the corresponding order.
	 * ```js
	 * const a = new THREE.Vector4( 0, 1, 0, 0 );
	 *
	 * //no arguments; will be initialised to (0, 0, 0, 1)
	 * const b = new THREE.Vector4( );
	 *
	 * const d = a.dot( b );
	 * ```
	 */ class Vector4 {
	    /**
		 * Alias for {@link Vector4#z}.
		 *
		 * @type {number}
		 */ get width() {
	        return this.z;
	    }
	    set width(value) {
	        this.z = value;
	    }
	    /**
		 * Alias for {@link Vector4#w}.
		 *
		 * @type {number}
		 */ get height() {
	        return this.w;
	    }
	    set height(value) {
	        this.w = value;
	    }
	    /**
		 * Sets the vector components.
		 *
		 * @param {number} x - The value of the x component.
		 * @param {number} y - The value of the y component.
		 * @param {number} z - The value of the z component.
		 * @param {number} w - The value of the w component.
		 * @return {Vector4} A reference to this vector.
		 */ set(x, y, z, w) {
	        this.x = x;
	        this.y = y;
	        this.z = z;
	        this.w = w;
	        return this;
	    }
	    /**
		 * Sets the vector components to the same value.
		 *
		 * @param {number} scalar - The value to set for all vector components.
		 * @return {Vector4} A reference to this vector.
		 */ setScalar(scalar) {
	        this.x = scalar;
	        this.y = scalar;
	        this.z = scalar;
	        this.w = scalar;
	        return this;
	    }
	    /**
		 * Sets the vector's x component to the given value
		 *
		 * @param {number} x - The value to set.
		 * @return {Vector4} A reference to this vector.
		 */ setX(x) {
	        this.x = x;
	        return this;
	    }
	    /**
		 * Sets the vector's y component to the given value
		 *
		 * @param {number} y - The value to set.
		 * @return {Vector4} A reference to this vector.
		 */ setY(y) {
	        this.y = y;
	        return this;
	    }
	    /**
		 * Sets the vector's z component to the given value
		 *
		 * @param {number} z - The value to set.
		 * @return {Vector4} A reference to this vector.
		 */ setZ(z) {
	        this.z = z;
	        return this;
	    }
	    /**
		 * Sets the vector's w component to the given value
		 *
		 * @param {number} w - The value to set.
		 * @return {Vector4} A reference to this vector.
		 */ setW(w) {
	        this.w = w;
	        return this;
	    }
	    /**
		 * Allows to set a vector component with an index.
		 *
		 * @param {number} index - The component index. `0` equals to x, `1` equals to y,
		 * `2` equals to z, `3` equals to w.
		 * @param {number} value - The value to set.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Returns the value of the vector component which matches the given index.
		 *
		 * @param {number} index - The component index. `0` equals to x, `1` equals to y,
		 * `2` equals to z, `3` equals to w.
		 * @return {number} A vector component value.
		 */ 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);
	        }
	    }
	    /**
		 * Returns a new vector with copied values from this instance.
		 *
		 * @return {Vector4} A clone of this instance.
		 */ clone() {
	        return new this.constructor(this.x, this.y, this.z, this.w);
	    }
	    /**
		 * Copies the values of the given vector to this instance.
		 *
		 * @param {Vector3|Vector4} v - The vector to copy.
		 * @return {Vector4} A reference to this vector.
		 */ copy(v) {
	        this.x = v.x;
	        this.y = v.y;
	        this.z = v.z;
	        this.w = v.w !== undefined ? v.w : 1;
	        return this;
	    }
	    /**
		 * Adds the given vector to this instance.
		 *
		 * @param {Vector4} v - The vector to add.
		 * @return {Vector4} A reference to this vector.
		 */ add(v) {
	        this.x += v.x;
	        this.y += v.y;
	        this.z += v.z;
	        this.w += v.w;
	        return this;
	    }
	    /**
		 * Adds the given scalar value to all components of this instance.
		 *
		 * @param {number} s - The scalar to add.
		 * @return {Vector4} A reference to this vector.
		 */ addScalar(s) {
	        this.x += s;
	        this.y += s;
	        this.z += s;
	        this.w += s;
	        return this;
	    }
	    /**
		 * Adds the given vectors and stores the result in this instance.
		 *
		 * @param {Vector4} a - The first vector.
		 * @param {Vector4} b - The second vector.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Adds the given vector scaled by the given factor to this instance.
		 *
		 * @param {Vector4} v - The vector.
		 * @param {number} s - The factor that scales `v`.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Subtracts the given vector from this instance.
		 *
		 * @param {Vector4} v - The vector to subtract.
		 * @return {Vector4} A reference to this vector.
		 */ sub(v) {
	        this.x -= v.x;
	        this.y -= v.y;
	        this.z -= v.z;
	        this.w -= v.w;
	        return this;
	    }
	    /**
		 * Subtracts the given scalar value from all components of this instance.
		 *
		 * @param {number} s - The scalar to subtract.
		 * @return {Vector4} A reference to this vector.
		 */ subScalar(s) {
	        this.x -= s;
	        this.y -= s;
	        this.z -= s;
	        this.w -= s;
	        return this;
	    }
	    /**
		 * Subtracts the given vectors and stores the result in this instance.
		 *
		 * @param {Vector4} a - The first vector.
		 * @param {Vector4} b - The second vector.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Multiplies the given vector with this instance.
		 *
		 * @param {Vector4} v - The vector to multiply.
		 * @return {Vector4} A reference to this vector.
		 */ multiply(v) {
	        this.x *= v.x;
	        this.y *= v.y;
	        this.z *= v.z;
	        this.w *= v.w;
	        return this;
	    }
	    /**
		 * Multiplies the given scalar value with all components of this instance.
		 *
		 * @param {number} scalar - The scalar to multiply.
		 * @return {Vector4} A reference to this vector.
		 */ multiplyScalar(scalar) {
	        this.x *= scalar;
	        this.y *= scalar;
	        this.z *= scalar;
	        this.w *= scalar;
	        return this;
	    }
	    /**
		 * Multiplies this vector with the given 4x4 matrix.
		 *
		 * @param {Matrix4} m - The 4x4 matrix.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Divides this instance by the given vector.
		 *
		 * @param {Vector4} v - The vector to divide.
		 * @return {Vector4} A reference to this vector.
		 */ divide(v) {
	        this.x /= v.x;
	        this.y /= v.y;
	        this.z /= v.z;
	        this.w /= v.w;
	        return this;
	    }
	    /**
		 * Divides this vector by the given scalar.
		 *
		 * @param {number} scalar - The scalar to divide.
		 * @return {Vector4} A reference to this vector.
		 */ divideScalar(scalar) {
	        return this.multiplyScalar(1 / scalar);
	    }
	    /**
		 * Sets the x, y and z components of this
		 * vector to the quaternion's axis and w to the angle.
		 *
		 * @param {Quaternion} q - The Quaternion to set.
		 * @return {Vector4} A reference to this vector.
		 */ setAxisAngleFromQuaternion(q) {
	        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
	        // q is assumed to be normalized
	        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;
	    }
	    /**
		 * Sets the x, y and z components of this
		 * vector to the axis of rotation and w to the angle.
		 *
		 * @param {Matrix4} m - A 4x4 matrix of which the upper left 3x3 matrix is a pure rotation matrix.
		 * @return {Vector4} A reference to this vector.
		 */ setAxisAngleFromRotationMatrix(m) {
	        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
	        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
	        let angle, x, y, z; // variables for result
	        const epsilon = 0.01, epsilon2 = 0.1, te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], 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) {
	            // singularity found
	            // first check for identity matrix which must have +1 for all terms
	            // in leading diagonal and zero in other terms
	            if (Math.abs(m12 + m21) < epsilon2 && Math.abs(m13 + m31) < epsilon2 && Math.abs(m23 + m32) < epsilon2 && Math.abs(m11 + m22 + m33 - 3) < epsilon2) {
	                // this singularity is identity matrix so angle = 0
	                this.set(1, 0, 0, 0);
	                return this; // zero angle, arbitrary axis
	            }
	            // otherwise this singularity is angle = 180
	            angle = Math.PI;
	            const xx = (m11 + 1) / 2;
	            const yy = (m22 + 1) / 2;
	            const zz = (m33 + 1) / 2;
	            const xy = (m12 + m21) / 4;
	            const xz = (m13 + m31) / 4;
	            const yz = (m23 + m32) / 4;
	            if (xx > yy && xx > zz) {
	                // m11 is the largest diagonal term
	                if (xx < epsilon) {
	                    x = 0;
	                    y = 0.707106781;
	                    z = 0.707106781;
	                } else {
	                    x = Math.sqrt(xx);
	                    y = xy / x;
	                    z = xz / x;
	                }
	            } else if (yy > zz) {
	                // m22 is the largest diagonal term
	                if (yy < epsilon) {
	                    x = 0.707106781;
	                    y = 0;
	                    z = 0.707106781;
	                } else {
	                    y = Math.sqrt(yy);
	                    x = xy / y;
	                    z = yz / y;
	                }
	            } else {
	                // m33 is the largest diagonal term so base result on this
	                if (zz < epsilon) {
	                    x = 0.707106781;
	                    y = 0.707106781;
	                    z = 0;
	                } else {
	                    z = Math.sqrt(zz);
	                    x = xz / z;
	                    y = yz / z;
	                }
	            }
	            this.set(x, y, z, angle);
	            return this; // return 180 deg rotation
	        }
	        // as we have reached here there are no singularities so we can handle normally
	        let s = Math.sqrt((m32 - m23) * (m32 - m23) + (m13 - m31) * (m13 - m31) + (m21 - m12) * (m21 - m12)); // used to normalize
	        if (Math.abs(s) < 0.001) s = 1;
	        // prevent divide by zero, should not happen if matrix is orthogonal and should be
	        // caught by singularity test above, but I've left it in just in case
	        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;
	    }
	    /**
		 * Sets the vector components to the position elements of the
		 * given transformation matrix.
		 *
		 * @param {Matrix4} m - The 4x4 matrix.
		 * @return {Vector4} A reference to this vector.
		 */ setFromMatrixPosition(m) {
	        const e = m.elements;
	        this.x = e[12];
	        this.y = e[13];
	        this.z = e[14];
	        this.w = e[15];
	        return this;
	    }
	    /**
		 * If this vector's x, y, z or w value is greater than the given vector's x, y, z or w
		 * value, replace that value with the corresponding min value.
		 *
		 * @param {Vector4} v - The vector.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * If this vector's x, y, z or w value is less than the given vector's x, y, z or w
		 * value, replace that value with the corresponding max value.
		 *
		 * @param {Vector4} v - The vector.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * If this vector's x, y, z or w value is greater than the max vector's x, y, z or w
		 * value, it is replaced by the corresponding value.
		 * If this vector's x, y, z or w value is less than the min vector's x, y, z or w value,
		 * it is replaced by the corresponding value.
		 *
		 * @param {Vector4} min - The minimum x, y and z values.
		 * @param {Vector4} max - The maximum x, y and z values in the desired range.
		 * @return {Vector4} A reference to this vector.
		 */ clamp(min, max) {
	        // assumes min < max, componentwise
	        this.x = clamp$1(this.x, min.x, max.x);
	        this.y = clamp$1(this.y, min.y, max.y);
	        this.z = clamp$1(this.z, min.z, max.z);
	        this.w = clamp$1(this.w, min.w, max.w);
	        return this;
	    }
	    /**
		 * If this vector's x, y, z or w values are greater than the max value, they are
		 * replaced by the max value.
		 * If this vector's x, y, z or w values are less than the min value, they are
		 * replaced by the min value.
		 *
		 * @param {number} minVal - The minimum value the components will be clamped to.
		 * @param {number} maxVal - The maximum value the components will be clamped to.
		 * @return {Vector4} A reference to this vector.
		 */ clampScalar(minVal, maxVal) {
	        this.x = clamp$1(this.x, minVal, maxVal);
	        this.y = clamp$1(this.y, minVal, maxVal);
	        this.z = clamp$1(this.z, minVal, maxVal);
	        this.w = clamp$1(this.w, minVal, maxVal);
	        return this;
	    }
	    /**
		 * If this vector's length is greater than the max value, it is replaced by
		 * the max value.
		 * If this vector's length is less than the min value, it is replaced by the
		 * min value.
		 *
		 * @param {number} min - The minimum value the vector length will be clamped to.
		 * @param {number} max - The maximum value the vector length will be clamped to.
		 * @return {Vector4} A reference to this vector.
		 */ clampLength(min, max) {
	        const length = this.length();
	        return this.divideScalar(length || 1).multiplyScalar(clamp$1(length, min, max));
	    }
	    /**
		 * The components of this vector are rounded down to the nearest integer value.
		 *
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * The components of this vector are rounded up to the nearest integer value.
		 *
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * The components of this vector are rounded to the nearest integer value
		 *
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * The components of this vector are rounded towards zero (up if negative,
		 * down if positive) to an integer value.
		 *
		 * @return {Vector4} A reference to this vector.
		 */ roundToZero() {
	        this.x = Math.trunc(this.x);
	        this.y = Math.trunc(this.y);
	        this.z = Math.trunc(this.z);
	        this.w = Math.trunc(this.w);
	        return this;
	    }
	    /**
		 * Inverts this vector - i.e. sets x = -x, y = -y, z = -z, w = -w.
		 *
		 * @return {Vector4} A reference to this vector.
		 */ negate() {
	        this.x = -this.x;
	        this.y = -this.y;
	        this.z = -this.z;
	        this.w = -this.w;
	        return this;
	    }
	    /**
		 * Calculates the dot product of the given vector with this instance.
		 *
		 * @param {Vector4} v - The vector to compute the dot product with.
		 * @return {number} The result of the dot product.
		 */ dot(v) {
	        return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
	    }
	    /**
		 * Computes the square of the Euclidean length (straight-line length) from
		 * (0, 0, 0, 0) to (x, y, z, w). If you are comparing the lengths of vectors, you should
		 * compare the length squared instead as it is slightly more efficient to calculate.
		 *
		 * @return {number} The square length of this vector.
		 */ lengthSq() {
	        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
	    }
	    /**
		 * Computes the  Euclidean length (straight-line length) from (0, 0, 0, 0) to (x, y, z, w).
		 *
		 * @return {number} The length of this vector.
		 */ length() {
	        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
	    }
	    /**
		 * Computes the Manhattan length of this vector.
		 *
		 * @return {number} The length of this vector.
		 */ manhattanLength() {
	        return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w);
	    }
	    /**
		 * Converts this vector to a unit vector - that is, sets it equal to a vector
		 * with the same direction as this one, but with a vector length of `1`.
		 *
		 * @return {Vector4} A reference to this vector.
		 */ normalize() {
	        return this.divideScalar(this.length() || 1);
	    }
	    /**
		 * Sets this vector to a vector with the same direction as this one, but
		 * with the specified length.
		 *
		 * @param {number} length - The new length of this vector.
		 * @return {Vector4} A reference to this vector.
		 */ setLength(length) {
	        return this.normalize().multiplyScalar(length);
	    }
	    /**
		 * Linearly interpolates between the given vector and this instance, where
		 * alpha is the percent distance along the line - alpha = 0 will be this
		 * vector, and alpha = 1 will be the given one.
		 *
		 * @param {Vector4} v - The vector to interpolate towards.
		 * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Linearly interpolates between the given vectors, where alpha is the percent
		 * distance along the line - alpha = 0 will be first vector, and alpha = 1 will
		 * be the second one. The result is stored in this instance.
		 *
		 * @param {Vector4} v1 - The first vector.
		 * @param {Vector4} v2 - The second vector.
		 * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Returns `true` if this vector is equal with the given one.
		 *
		 * @param {Vector4} v - The vector to test for equality.
		 * @return {boolean} Whether this vector is equal with the given one.
		 */ equals(v) {
	        return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w;
	    }
	    /**
		 * Sets this vector's x value to be `array[ offset ]`, y value to be `array[ offset + 1 ]`,
		 * z value to be `array[ offset + 2 ]`, w value to be `array[ offset + 3 ]`.
		 *
		 * @param {Array<number>} array - An array holding the vector component values.
		 * @param {number} [offset=0] - The offset into the array.
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Writes the components of this vector to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the vector components.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The vector components.
		 */ 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;
	    }
	    /**
		 * Sets the components of this vector from the given buffer attribute.
		 *
		 * @param {BufferAttribute} attribute - The buffer attribute holding vector data.
		 * @param {number} index - The index into the attribute.
		 * @return {Vector4} A reference to this vector.
		 */ fromBufferAttribute(attribute, index) {
	        this.x = attribute.getX(index);
	        this.y = attribute.getY(index);
	        this.z = attribute.getZ(index);
	        this.w = attribute.getW(index);
	        return this;
	    }
	    /**
		 * Sets each component of this vector to a pseudo-random value between `0` and
		 * `1`, excluding `1`.
		 *
		 * @return {Vector4} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Constructs a new 4D vector.
		 *
		 * @param {number} [x=0] - The x value of this vector.
		 * @param {number} [y=0] - The y value of this vector.
		 * @param {number} [z=0] - The z value of this vector.
		 * @param {number} [w=1] - The w value of this vector.
		 */ constructor(x = 0, y = 0, z = 0, w = 1){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ Vector4.prototype.isVector4 = true;
	        /**
			 * The x value of this vector.
			 *
			 * @type {number}
			 */ this.x = x;
	        /**
			 * The y value of this vector.
			 *
			 * @type {number}
			 */ this.y = y;
	        /**
			 * The z value of this vector.
			 *
			 * @type {number}
			 */ this.z = z;
	        /**
			 * The w value of this vector.
			 *
			 * @type {number}
			 */ this.w = w;
	    }
	}
	/*
	 In options, we can specify:
	 * Texture parameters for an auto-generated target texture
	 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
	*/ class RenderTarget extends EventDispatcher {
	    get texture() {
	        return this.textures[0];
	    }
	    set texture(value) {
	        this.textures[0] = value;
	    }
	    set depthTexture(current) {
	        if (this._depthTexture !== null) this._depthTexture.renderTarget = null;
	        if (current !== null) current.renderTarget = this;
	        this._depthTexture = current;
	    }
	    get depthTexture() {
	        return this._depthTexture;
	    }
	    setSize(width, height, depth = 1) {
	        if (this.width !== width || this.height !== height || this.depth !== depth) {
	            this.width = width;
	            this.height = height;
	            this.depth = depth;
	            for(let i = 0, il = this.textures.length; i < il; i++){
	                this.textures[i].image.width = width;
	                this.textures[i].image.height = height;
	                this.textures[i].image.depth = depth;
	            }
	            this.dispose();
	        }
	        this.viewport.set(0, 0, width, height);
	        this.scissor.set(0, 0, width, height);
	    }
	    clone() {
	        return new this.constructor().copy(this);
	    }
	    copy(source) {
	        this.width = source.width;
	        this.height = source.height;
	        this.depth = source.depth;
	        this.scissor.copy(source.scissor);
	        this.scissorTest = source.scissorTest;
	        this.viewport.copy(source.viewport);
	        this.textures.length = 0;
	        for(let i = 0, il = source.textures.length; i < il; i++){
	            this.textures[i] = source.textures[i].clone();
	            this.textures[i].isRenderTargetTexture = true;
	            this.textures[i].renderTarget = this;
	            // ensure image object is not shared, see #20328
	            const image = Object.assign({}, source.textures[i].image);
	            this.textures[i].source = new Source(image);
	        }
	        this.depthBuffer = source.depthBuffer;
	        this.stencilBuffer = source.stencilBuffer;
	        this.resolveDepthBuffer = source.resolveDepthBuffer;
	        this.resolveStencilBuffer = source.resolveStencilBuffer;
	        if (source.depthTexture !== null) this.depthTexture = source.depthTexture.clone();
	        this.samples = source.samples;
	        return this;
	    }
	    dispose() {
	        this.dispatchEvent({
	            type: 'dispose'
	        });
	    }
	    constructor(width = 1, height = 1, options = {}){
	        super();
	        this.isRenderTarget = true;
	        this.width = width;
	        this.height = height;
	        this.depth = 1;
	        this.scissor = new Vector4(0, 0, width, height);
	        this.scissorTest = false;
	        this.viewport = new Vector4(0, 0, width, height);
	        const image = {
	            width: width,
	            height: height,
	            depth: 1
	        };
	        options = Object.assign({
	            generateMipmaps: false,
	            internalFormat: null,
	            minFilter: LinearFilter,
	            depthBuffer: true,
	            stencilBuffer: false,
	            resolveDepthBuffer: true,
	            resolveStencilBuffer: true,
	            depthTexture: null,
	            samples: 0,
	            count: 1
	        }, options);
	        const texture = new Texture$1(image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace);
	        texture.flipY = false;
	        texture.generateMipmaps = options.generateMipmaps;
	        texture.internalFormat = options.internalFormat;
	        this.textures = [];
	        const count = options.count;
	        for(let i = 0; i < count; i++){
	            this.textures[i] = texture.clone();
	            this.textures[i].isRenderTargetTexture = true;
	            this.textures[i].renderTarget = this;
	        }
	        this.depthBuffer = options.depthBuffer;
	        this.stencilBuffer = options.stencilBuffer;
	        this.resolveDepthBuffer = options.resolveDepthBuffer;
	        this.resolveStencilBuffer = options.resolveStencilBuffer;
	        this._depthTexture = null;
	        this.depthTexture = options.depthTexture;
	        this.samples = options.samples;
	    }
	}
	class WebGLRenderTarget extends RenderTarget {
	    constructor(width = 1, height = 1, options = {}){
	        super(width, height, options);
	        this.isWebGLRenderTarget = true;
	    }
	}
	class DataArrayTexture extends Texture$1 {
	    addLayerUpdate(layerIndex) {
	        this.layerUpdates.add(layerIndex);
	    }
	    clearLayerUpdates() {
	        this.layerUpdates.clear();
	    }
	    constructor(data = null, width = 1, height = 1, depth = 1){
	        super(null);
	        this.isDataArrayTexture = true;
	        this.image = {
	            data,
	            width,
	            height,
	            depth
	        };
	        this.magFilter = NearestFilter;
	        this.minFilter = NearestFilter;
	        this.wrapR = ClampToEdgeWrapping;
	        this.generateMipmaps = false;
	        this.flipY = false;
	        this.unpackAlignment = 1;
	        this.layerUpdates = new Set();
	    }
	}
	class Data3DTexture extends Texture$1 {
	    constructor(data = null, width = 1, height = 1, depth = 1){
	        // We're going to add .setXXX() methods for setting properties later.
	        // Users can still set in Data3DTexture directly.
	        //
	        //	const texture = new THREE.Data3DTexture( data, width, height, depth );
	        // 	texture.anisotropy = 16;
	        //
	        // See #14839
	        super(null);
	        this.isData3DTexture = true;
	        this.image = {
	            data,
	            width,
	            height,
	            depth
	        };
	        this.magFilter = NearestFilter;
	        this.minFilter = NearestFilter;
	        this.wrapR = ClampToEdgeWrapping;
	        this.generateMipmaps = false;
	        this.flipY = false;
	        this.unpackAlignment = 1;
	    }
	}
	/**
	 * Class for representing a Quaternion. Quaternions are used in three.js to represent rotations.
	 *
	 * Iterating through a vector instance will yield its components `(x, y, z, w)` in
	 * the corresponding order.
	 *
	 * Note that three.js expects Quaternions to be normalized.
	 * ```js
	 * const quaternion = new THREE.Quaternion();
	 * quaternion.setFromAxisAngle( new THREE.Vector3( 0, 1, 0 ), Math.PI / 2 );
	 *
	 * const vector = new THREE.Vector3( 1, 0, 0 );
	 * vector.applyQuaternion( quaternion );
	 * ```
	 */ class Quaternion {
	    /**
		 * Interpolates between two quaternions via SLERP. This implementation assumes the
		 * quaternion data are managed  in flat arrays.
		 *
		 * @param {Array<number>} dst - The destination array.
		 * @param {number} dstOffset - An offset into the destination array.
		 * @param {Array<number>} src0 - The source array of the first quaternion.
		 * @param {number} srcOffset0 - An offset into the first source array.
		 * @param {Array<number>} src1 -  The source array of the second quaternion.
		 * @param {number} srcOffset1 - An offset into the second source array.
		 * @param {number} t - The interpolation factor in the range `[0,1]`.
		 * @see {@link Quaternion#slerp}
		 */ static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
	        // fuzz-free, array-based Quaternion SLERP operation
	        let x0 = src0[srcOffset0 + 0], y0 = src0[srcOffset0 + 1], z0 = src0[srcOffset0 + 2], w0 = src0[srcOffset0 + 3];
	        const x1 = src1[srcOffset1 + 0], y1 = src1[srcOffset1 + 1], z1 = src1[srcOffset1 + 2], w1 = src1[srcOffset1 + 3];
	        if (t === 0) {
	            dst[dstOffset + 0] = x0;
	            dst[dstOffset + 1] = y0;
	            dst[dstOffset + 2] = z0;
	            dst[dstOffset + 3] = w0;
	            return;
	        }
	        if (t === 1) {
	            dst[dstOffset + 0] = x1;
	            dst[dstOffset + 1] = y1;
	            dst[dstOffset + 2] = z1;
	            dst[dstOffset + 3] = w1;
	            return;
	        }
	        if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
	            let s = 1 - t;
	            const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, dir = cos >= 0 ? 1 : -1, sqrSin = 1 - cos * cos;
	            // Skip the Slerp for tiny steps to avoid numeric problems:
	            if (sqrSin > Number.EPSILON) {
	                const sin = Math.sqrt(sqrSin), len = Math.atan2(sin, cos * dir);
	                s = Math.sin(s * len) / sin;
	                t = Math.sin(t * len) / sin;
	            }
	            const tDir = t * dir;
	            x0 = x0 * s + x1 * tDir;
	            y0 = y0 * s + y1 * tDir;
	            z0 = z0 * s + z1 * tDir;
	            w0 = w0 * s + w1 * tDir;
	            // Normalize in case we just did a lerp:
	            if (s === 1 - t) {
	                const f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
	                x0 *= f;
	                y0 *= f;
	                z0 *= f;
	                w0 *= f;
	            }
	        }
	        dst[dstOffset] = x0;
	        dst[dstOffset + 1] = y0;
	        dst[dstOffset + 2] = z0;
	        dst[dstOffset + 3] = w0;
	    }
	    /**
		 * Multiplies two quaternions. This implementation assumes the quaternion data are managed
		 * in flat arrays.
		 *
		 * @param {Array<number>} dst - The destination array.
		 * @param {number} dstOffset - An offset into the destination array.
		 * @param {Array<number>} src0 - The source array of the first quaternion.
		 * @param {number} srcOffset0 - An offset into the first source array.
		 * @param {Array<number>} src1 -  The source array of the second quaternion.
		 * @param {number} srcOffset1 - An offset into the second source array.
		 * @return {Array<number>} The destination array.
		 * @see {@link Quaternion#multiplyQuaternions}.
		 */ static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
	        const x0 = src0[srcOffset0];
	        const y0 = src0[srcOffset0 + 1];
	        const z0 = src0[srcOffset0 + 2];
	        const w0 = src0[srcOffset0 + 3];
	        const x1 = src1[srcOffset1];
	        const y1 = src1[srcOffset1 + 1];
	        const z1 = src1[srcOffset1 + 2];
	        const w1 = src1[srcOffset1 + 3];
	        dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
	        dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
	        dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
	        dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
	        return dst;
	    }
	    /**
		 * The x value of this quaternion.
		 *
		 * @type {number}
		 * @default 0
		 */ get x() {
	        return this._x;
	    }
	    set x(value) {
	        this._x = value;
	        this._onChangeCallback();
	    }
	    /**
		 * The y value of this quaternion.
		 *
		 * @type {number}
		 * @default 0
		 */ get y() {
	        return this._y;
	    }
	    set y(value) {
	        this._y = value;
	        this._onChangeCallback();
	    }
	    /**
		 * The z value of this quaternion.
		 *
		 * @type {number}
		 * @default 0
		 */ get z() {
	        return this._z;
	    }
	    set z(value) {
	        this._z = value;
	        this._onChangeCallback();
	    }
	    /**
		 * The w value of this quaternion.
		 *
		 * @type {number}
		 * @default 1
		 */ get w() {
	        return this._w;
	    }
	    set w(value) {
	        this._w = value;
	        this._onChangeCallback();
	    }
	    /**
		 * Sets the quaternion components.
		 *
		 * @param {number} x - The x value of this quaternion.
		 * @param {number} y - The y value of this quaternion.
		 * @param {number} z - The z value of this quaternion.
		 * @param {number} w - The w value of this quaternion.
		 * @return {Quaternion} A reference to this quaternion.
		 */ set(x, y, z, w) {
	        this._x = x;
	        this._y = y;
	        this._z = z;
	        this._w = w;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Returns a new quaternion with copied values from this instance.
		 *
		 * @return {Quaternion} A clone of this instance.
		 */ clone() {
	        return new this.constructor(this._x, this._y, this._z, this._w);
	    }
	    /**
		 * Copies the values of the given quaternion to this instance.
		 *
		 * @param {Quaternion} quaternion - The quaternion to copy.
		 * @return {Quaternion} A reference to this quaternion.
		 */ copy(quaternion) {
	        this._x = quaternion.x;
	        this._y = quaternion.y;
	        this._z = quaternion.z;
	        this._w = quaternion.w;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Sets this quaternion from the rotation specified by the given
		 * Euler angles.
		 *
		 * @param {Euler} euler - The Euler angles.
		 * @param {boolean} [update=true] - Whether the internal `onChange` callback should be executed or not.
		 * @return {Quaternion} A reference to this quaternion.
		 */ setFromEuler(euler, update = true) {
	        const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
	        // http://www.mathworks.com/matlabcentral/fileexchange/
	        // 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
	        //	content/SpinCalc.m
	        const cos = Math.cos;
	        const sin = Math.sin;
	        const c1 = cos(x / 2);
	        const c2 = cos(y / 2);
	        const c3 = cos(z / 2);
	        const s1 = sin(x / 2);
	        const s2 = sin(y / 2);
	        const s3 = sin(z / 2);
	        switch(order){
	            case 'XYZ':
	                this._x = s1 * c2 * c3 + c1 * s2 * s3;
	                this._y = c1 * s2 * c3 - s1 * c2 * s3;
	                this._z = c1 * c2 * s3 + s1 * s2 * c3;
	                this._w = c1 * c2 * c3 - s1 * s2 * s3;
	                break;
	            case 'YXZ':
	                this._x = s1 * c2 * c3 + c1 * s2 * s3;
	                this._y = c1 * s2 * c3 - s1 * c2 * s3;
	                this._z = c1 * c2 * s3 - s1 * s2 * c3;
	                this._w = c1 * c2 * c3 + s1 * s2 * s3;
	                break;
	            case 'ZXY':
	                this._x = s1 * c2 * c3 - c1 * s2 * s3;
	                this._y = c1 * s2 * c3 + s1 * c2 * s3;
	                this._z = c1 * c2 * s3 + s1 * s2 * c3;
	                this._w = c1 * c2 * c3 - s1 * s2 * s3;
	                break;
	            case 'ZYX':
	                this._x = s1 * c2 * c3 - c1 * s2 * s3;
	                this._y = c1 * s2 * c3 + s1 * c2 * s3;
	                this._z = c1 * c2 * s3 - s1 * s2 * c3;
	                this._w = c1 * c2 * c3 + s1 * s2 * s3;
	                break;
	            case 'YZX':
	                this._x = s1 * c2 * c3 + c1 * s2 * s3;
	                this._y = c1 * s2 * c3 + s1 * c2 * s3;
	                this._z = c1 * c2 * s3 - s1 * s2 * c3;
	                this._w = c1 * c2 * c3 - s1 * s2 * s3;
	                break;
	            case 'XZY':
	                this._x = s1 * c2 * c3 - c1 * s2 * s3;
	                this._y = c1 * s2 * c3 - s1 * c2 * s3;
	                this._z = c1 * c2 * s3 + s1 * s2 * c3;
	                this._w = c1 * c2 * c3 + s1 * s2 * s3;
	                break;
	            default:
	                console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
	        }
	        if (update === true) this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Sets this quaternion from the given axis and angle.
		 *
		 * @param {Vector3} axis - The normalized axis.
		 * @param {number} angle - The angle in radians.
		 * @return {Quaternion} A reference to this quaternion.
		 */ setFromAxisAngle(axis, angle) {
	        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
	        const halfAngle = angle / 2, s = Math.sin(halfAngle);
	        this._x = axis.x * s;
	        this._y = axis.y * s;
	        this._z = axis.z * s;
	        this._w = Math.cos(halfAngle);
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Sets this quaternion from the given rotation matrix.
		 *
		 * @param {Matrix4} m - A 4x4 matrix of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
		 * @return {Quaternion} A reference to this quaternion.
		 */ setFromRotationMatrix(m) {
	        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
	        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
	        const te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10], trace = m11 + m22 + m33;
	        if (trace > 0) {
	            const s = 0.5 / Math.sqrt(trace + 1.0);
	            this._w = 0.25 / s;
	            this._x = (m32 - m23) * s;
	            this._y = (m13 - m31) * s;
	            this._z = (m21 - m12) * s;
	        } else if (m11 > m22 && m11 > m33) {
	            const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
	            this._w = (m32 - m23) / s;
	            this._x = 0.25 * s;
	            this._y = (m12 + m21) / s;
	            this._z = (m13 + m31) / s;
	        } else if (m22 > m33) {
	            const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
	            this._w = (m13 - m31) / s;
	            this._x = (m12 + m21) / s;
	            this._y = 0.25 * s;
	            this._z = (m23 + m32) / s;
	        } else {
	            const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
	            this._w = (m21 - m12) / s;
	            this._x = (m13 + m31) / s;
	            this._y = (m23 + m32) / s;
	            this._z = 0.25 * s;
	        }
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Sets this quaternion to the rotation required to rotate the direction vector
		 * `vFrom` to the direction vector `vTo`.
		 *
		 * @param {Vector3} vFrom - The first (normalized) direction vector.
		 * @param {Vector3} vTo - The second (normalized) direction vector.
		 * @return {Quaternion} A reference to this quaternion.
		 */ setFromUnitVectors(vFrom, vTo) {
	        // assumes direction vectors vFrom and vTo are normalized
	        let r = vFrom.dot(vTo) + 1;
	        if (r < Number.EPSILON) {
	            // vFrom and vTo point in opposite directions
	            r = 0;
	            if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
	                this._x = -vFrom.y;
	                this._y = vFrom.x;
	                this._z = 0;
	                this._w = r;
	            } else {
	                this._x = 0;
	                this._y = -vFrom.z;
	                this._z = vFrom.y;
	                this._w = r;
	            }
	        } else {
	            // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
	            this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
	            this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
	            this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
	            this._w = r;
	        }
	        return this.normalize();
	    }
	    /**
		 * Returns the angle between this quaternion and the given one in radians.
		 *
		 * @param {Quaternion} q - The quaternion to compute the angle with.
		 * @return {number} The angle in radians.
		 */ angleTo(q) {
	        return 2 * Math.acos(Math.abs(clamp$1(this.dot(q), -1, 1)));
	    }
	    /**
		 * Rotates this quaternion by a given angular step to the given quaternion.
		 * The method ensures that the final quaternion will not overshoot `q`.
		 *
		 * @param {Quaternion} q - The target quaternion.
		 * @param {number} step - The angular step in radians.
		 * @return {Quaternion} A reference to this quaternion.
		 */ rotateTowards(q, step) {
	        const angle = this.angleTo(q);
	        if (angle === 0) return this;
	        const t = Math.min(1, step / angle);
	        this.slerp(q, t);
	        return this;
	    }
	    /**
		 * Sets this quaternion to the identity quaternion; that is, to the
		 * quaternion that represents "no rotation".
		 *
		 * @return {Quaternion} A reference to this quaternion.
		 */ identity() {
	        return this.set(0, 0, 0, 1);
	    }
	    /**
		 * Inverts this quaternion via {@link Quaternion#conjugate}. The
		 * quaternion is assumed to have unit length.
		 *
		 * @return {Quaternion} A reference to this quaternion.
		 */ invert() {
	        return this.conjugate();
	    }
	    /**
		 * Returns the rotational conjugate of this quaternion. The conjugate of a
		 * quaternion represents the same rotation in the opposite direction about
		 * the rotational axis.
		 *
		 * @return {Quaternion} A reference to this quaternion.
		 */ conjugate() {
	        this._x *= -1;
	        this._y *= -1;
	        this._z *= -1;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Calculates the dot product of this quaternion and the given one.
		 *
		 * @param {Quaternion} v - The quaternion to compute the dot product with.
		 * @return {number} The result of the dot product.
		 */ dot(v) {
	        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
	    }
	    /**
		 * Computes the squared Euclidean length (straight-line length) of this quaternion,
		 * considered as a 4 dimensional vector. This can be useful if you are comparing the
		 * lengths of two quaternions, as this is a slightly more efficient calculation than
		 * {@link Quaternion#length}.
		 *
		 * @return {number} The squared Euclidean length.
		 */ lengthSq() {
	        return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
	    }
	    /**
		 * Computes the Euclidean length (straight-line length) of this quaternion,
		 * considered as a 4 dimensional vector.
		 *
		 * @return {number} The Euclidean length.
		 */ length() {
	        return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
	    }
	    /**
		 * Normalizes this quaternion - that is, calculated the quaternion that performs
		 * the same rotation as this one, but has a length equal to `1`.
		 *
		 * @return {Quaternion} A reference to this quaternion.
		 */ normalize() {
	        let l = this.length();
	        if (l === 0) {
	            this._x = 0;
	            this._y = 0;
	            this._z = 0;
	            this._w = 1;
	        } else {
	            l = 1 / l;
	            this._x = this._x * l;
	            this._y = this._y * l;
	            this._z = this._z * l;
	            this._w = this._w * l;
	        }
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Multiplies this quaternion by the given one.
		 *
		 * @param {Quaternion} q - The quaternion.
		 * @return {Quaternion} A reference to this quaternion.
		 */ multiply(q) {
	        return this.multiplyQuaternions(this, q);
	    }
	    /**
		 * Pre-multiplies this quaternion by the given one.
		 *
		 * @param {Quaternion} q - The quaternion.
		 * @return {Quaternion} A reference to this quaternion.
		 */ premultiply(q) {
	        return this.multiplyQuaternions(q, this);
	    }
	    /**
		 * Multiplies the given quaternions and stores the result in this instance.
		 *
		 * @param {Quaternion} a - The first quaternion.
		 * @param {Quaternion} b - The second quaternion.
		 * @return {Quaternion} A reference to this quaternion.
		 */ multiplyQuaternions(a, b) {
	        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
	        const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
	        const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
	        this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
	        this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
	        this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
	        this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Performs a spherical linear interpolation between quaternions.
		 *
		 * @param {Quaternion} qb - The target quaternion.
		 * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
		 * @return {Quaternion} A reference to this quaternion.
		 */ slerp(qb, t) {
	        if (t === 0) return this;
	        if (t === 1) return this.copy(qb);
	        const x = this._x, y = this._y, z = this._z, w = this._w;
	        // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
	        let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
	        if (cosHalfTheta < 0) {
	            this._w = -qb._w;
	            this._x = -qb._x;
	            this._y = -qb._y;
	            this._z = -qb._z;
	            cosHalfTheta = -cosHalfTheta;
	        } else {
	            this.copy(qb);
	        }
	        if (cosHalfTheta >= 1.0) {
	            this._w = w;
	            this._x = x;
	            this._y = y;
	            this._z = z;
	            return this;
	        }
	        const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
	        if (sqrSinHalfTheta <= Number.EPSILON) {
	            const s = 1 - t;
	            this._w = s * w + t * this._w;
	            this._x = s * x + t * this._x;
	            this._y = s * y + t * this._y;
	            this._z = s * z + t * this._z;
	            this.normalize(); // normalize calls _onChangeCallback()
	            return this;
	        }
	        const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
	        const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
	        const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta, ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
	        this._w = w * ratioA + this._w * ratioB;
	        this._x = x * ratioA + this._x * ratioB;
	        this._y = y * ratioA + this._y * ratioB;
	        this._z = z * ratioA + this._z * ratioB;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Performs a spherical linear interpolation between the given quaternions
		 * and stores the result in this quaternion.
		 *
		 * @param {Quaternion} qa - The source quaternion.
		 * @param {Quaternion} qb - The target quaternion.
		 * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
		 * @return {Quaternion} A reference to this quaternion.
		 */ slerpQuaternions(qa, qb, t) {
	        return this.copy(qa).slerp(qb, t);
	    }
	    /**
		 * Sets this quaternion to a uniformly random, normalized quaternion.
		 *
		 * @return {Quaternion} A reference to this quaternion.
		 */ random() {
	        // Ken Shoemake
	        // Uniform random rotations
	        // D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.
	        const theta1 = 2 * Math.PI * Math.random();
	        const theta2 = 2 * Math.PI * Math.random();
	        const x0 = Math.random();
	        const r1 = Math.sqrt(1 - x0);
	        const r2 = Math.sqrt(x0);
	        return this.set(r1 * Math.sin(theta1), r1 * Math.cos(theta1), r2 * Math.sin(theta2), r2 * Math.cos(theta2));
	    }
	    /**
		 * Returns `true` if this quaternion is equal with the given one.
		 *
		 * @param {Quaternion} quaternion - The quaternion to test for equality.
		 * @return {boolean} Whether this quaternion is equal with the given one.
		 */ equals(quaternion) {
	        return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
	    }
	    /**
		 * Sets this quaternion's components from the given array.
		 *
		 * @param {Array<number>} array - An array holding the quaternion component values.
		 * @param {number} [offset=0] - The offset into the array.
		 * @return {Quaternion} A reference to this quaternion.
		 */ fromArray(array, offset = 0) {
	        this._x = array[offset];
	        this._y = array[offset + 1];
	        this._z = array[offset + 2];
	        this._w = array[offset + 3];
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Writes the components of this quaternion to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the quaternion components.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The quaternion components.
		 */ 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;
	    }
	    /**
		 * Sets the components of this quaternion from the given buffer attribute.
		 *
		 * @param {BufferAttribute} attribute - The buffer attribute holding quaternion data.
		 * @param {number} index - The index into the attribute.
		 * @return {Quaternion} A reference to this quaternion.
		 */ fromBufferAttribute(attribute, index) {
	        this._x = attribute.getX(index);
	        this._y = attribute.getY(index);
	        this._z = attribute.getZ(index);
	        this._w = attribute.getW(index);
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * This methods defines the serialization result of this class. Returns the
		 * numerical elements of this quaternion in an array of format `[x, y, z, w]`.
		 *
		 * @return {Array<number>} The serialized quaternion.
		 */ toJSON() {
	        return this.toArray();
	    }
	    _onChange(callback) {
	        this._onChangeCallback = callback;
	        return this;
	    }
	    _onChangeCallback() {}
	    *[Symbol.iterator]() {
	        yield this._x;
	        yield this._y;
	        yield this._z;
	        yield this._w;
	    }
	    /**
		 * Constructs a new quaternion.
		 *
		 * @param {number} [x=0] - The x value of this quaternion.
		 * @param {number} [y=0] - The y value of this quaternion.
		 * @param {number} [z=0] - The z value of this quaternion.
		 * @param {number} [w=1] - The w value of this quaternion.
		 */ constructor(x = 0, y = 0, z = 0, w = 1){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isQuaternion = true;
	        this._x = x;
	        this._y = y;
	        this._z = z;
	        this._w = w;
	    }
	}
	/**
	 * Class representing a 3D vector. A 3D vector is an ordered triplet of numbers
	 * (labeled x, y and z), which can be used to represent a number of things, such as:
	 *
	 * - A point in 3D space.
	 * - A direction and length in 3D space. In three.js the length will
	 * always be the Euclidean distance(straight-line distance) from `(0, 0, 0)` to `(x, y, z)`
	 * and the direction is also measured from `(0, 0, 0)` towards `(x, y, z)`.
	 * - Any arbitrary ordered triplet of numbers.
	 *
	 * There are other things a 3D vector can be used to represent, such as
	 * momentum vectors and so on, however these are the most
	 * common uses in three.js.
	 *
	 * Iterating through a vector instance will yield its components `(x, y, z)` in
	 * the corresponding order.
	 * ```js
	 * const a = new THREE.Vector3( 0, 1, 0 );
	 *
	 * //no arguments; will be initialised to (0, 0, 0)
	 * const b = new THREE.Vector3( );
	 *
	 * const d = a.distanceTo( b );
	 * ```
	 */ class Vector3 {
	    /**
		 * Sets the vector components.
		 *
		 * @param {number} x - The value of the x component.
		 * @param {number} y - The value of the y component.
		 * @param {number} z - The value of the z component.
		 * @return {Vector3} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Sets the vector components to the same value.
		 *
		 * @param {number} scalar - The value to set for all vector components.
		 * @return {Vector3} A reference to this vector.
		 */ setScalar(scalar) {
	        this.x = scalar;
	        this.y = scalar;
	        this.z = scalar;
	        return this;
	    }
	    /**
		 * Sets the vector's x component to the given value
		 *
		 * @param {number} x - The value to set.
		 * @return {Vector3} A reference to this vector.
		 */ setX(x) {
	        this.x = x;
	        return this;
	    }
	    /**
		 * Sets the vector's y component to the given value
		 *
		 * @param {number} y - The value to set.
		 * @return {Vector3} A reference to this vector.
		 */ setY(y) {
	        this.y = y;
	        return this;
	    }
	    /**
		 * Sets the vector's z component to the given value
		 *
		 * @param {number} z - The value to set.
		 * @return {Vector3} A reference to this vector.
		 */ setZ(z) {
	        this.z = z;
	        return this;
	    }
	    /**
		 * Allows to set a vector component with an index.
		 *
		 * @param {number} index - The component index. `0` equals to x, `1` equals to y, `2` equals to z.
		 * @param {number} value - The value to set.
		 * @return {Vector3} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Returns the value of the vector component which matches the given index.
		 *
		 * @param {number} index - The component index. `0` equals to x, `1` equals to y, `2` equals to z.
		 * @return {number} A vector component value.
		 */ 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);
	        }
	    }
	    /**
		 * Returns a new vector with copied values from this instance.
		 *
		 * @return {Vector3} A clone of this instance.
		 */ clone() {
	        return new this.constructor(this.x, this.y, this.z);
	    }
	    /**
		 * Copies the values of the given vector to this instance.
		 *
		 * @param {Vector3} v - The vector to copy.
		 * @return {Vector3} A reference to this vector.
		 */ copy(v) {
	        this.x = v.x;
	        this.y = v.y;
	        this.z = v.z;
	        return this;
	    }
	    /**
		 * Adds the given vector to this instance.
		 *
		 * @param {Vector3} v - The vector to add.
		 * @return {Vector3} A reference to this vector.
		 */ add(v) {
	        this.x += v.x;
	        this.y += v.y;
	        this.z += v.z;
	        return this;
	    }
	    /**
		 * Adds the given scalar value to all components of this instance.
		 *
		 * @param {number} s - The scalar to add.
		 * @return {Vector3} A reference to this vector.
		 */ addScalar(s) {
	        this.x += s;
	        this.y += s;
	        this.z += s;
	        return this;
	    }
	    /**
		 * Adds the given vectors and stores the result in this instance.
		 *
		 * @param {Vector3} a - The first vector.
		 * @param {Vector3} b - The second vector.
		 * @return {Vector3} A reference to this vector.
		 */ addVectors(a, b) {
	        this.x = a.x + b.x;
	        this.y = a.y + b.y;
	        this.z = a.z + b.z;
	        return this;
	    }
	    /**
		 * Adds the given vector scaled by the given factor to this instance.
		 *
		 * @param {Vector3|Vector4} v - The vector.
		 * @param {number} s - The factor that scales `v`.
		 * @return {Vector3} A reference to this vector.
		 */ addScaledVector(v, s) {
	        this.x += v.x * s;
	        this.y += v.y * s;
	        this.z += v.z * s;
	        return this;
	    }
	    /**
		 * Subtracts the given vector from this instance.
		 *
		 * @param {Vector3} v - The vector to subtract.
		 * @return {Vector3} A reference to this vector.
		 */ sub(v) {
	        this.x -= v.x;
	        this.y -= v.y;
	        this.z -= v.z;
	        return this;
	    }
	    /**
		 * Subtracts the given scalar value from all components of this instance.
		 *
		 * @param {number} s - The scalar to subtract.
		 * @return {Vector3} A reference to this vector.
		 */ subScalar(s) {
	        this.x -= s;
	        this.y -= s;
	        this.z -= s;
	        return this;
	    }
	    /**
		 * Subtracts the given vectors and stores the result in this instance.
		 *
		 * @param {Vector3} a - The first vector.
		 * @param {Vector3} b - The second vector.
		 * @return {Vector3} A reference to this vector.
		 */ subVectors(a, b) {
	        this.x = a.x - b.x;
	        this.y = a.y - b.y;
	        this.z = a.z - b.z;
	        return this;
	    }
	    /**
		 * Multiplies the given vector with this instance.
		 *
		 * @param {Vector3} v - The vector to multiply.
		 * @return {Vector3} A reference to this vector.
		 */ multiply(v) {
	        this.x *= v.x;
	        this.y *= v.y;
	        this.z *= v.z;
	        return this;
	    }
	    /**
		 * Multiplies the given scalar value with all components of this instance.
		 *
		 * @param {number} scalar - The scalar to multiply.
		 * @return {Vector3} A reference to this vector.
		 */ multiplyScalar(scalar) {
	        this.x *= scalar;
	        this.y *= scalar;
	        this.z *= scalar;
	        return this;
	    }
	    /**
		 * Multiplies the given vectors and stores the result in this instance.
		 *
		 * @param {Vector3} a - The first vector.
		 * @param {Vector3} b - The second vector.
		 * @return {Vector3} A reference to this vector.
		 */ multiplyVectors(a, b) {
	        this.x = a.x * b.x;
	        this.y = a.y * b.y;
	        this.z = a.z * b.z;
	        return this;
	    }
	    /**
		 * Applies the given Euler rotation to this vector.
		 *
		 * @param {Euler} euler - The Euler angles.
		 * @return {Vector3} A reference to this vector.
		 */ applyEuler(euler) {
	        return this.applyQuaternion(_quaternion$4.setFromEuler(euler));
	    }
	    /**
		 * Applies a rotation specified by an axis and an angle to this vector.
		 *
		 * @param {Vector3} axis - A normalized vector representing the rotation axis.
		 * @param {number} angle - The angle in radians.
		 * @return {Vector3} A reference to this vector.
		 */ applyAxisAngle(axis, angle) {
	        return this.applyQuaternion(_quaternion$4.setFromAxisAngle(axis, angle));
	    }
	    /**
		 * Multiplies this vector with the given 3x3 matrix.
		 *
		 * @param {Matrix3} m - The 3x3 matrix.
		 * @return {Vector3} A reference to this vector.
		 */ applyMatrix3(m) {
	        const x = this.x, y = this.y, z = this.z;
	        const e = m.elements;
	        this.x = e[0] * x + e[3] * y + e[6] * z;
	        this.y = e[1] * x + e[4] * y + e[7] * z;
	        this.z = e[2] * x + e[5] * y + e[8] * z;
	        return this;
	    }
	    /**
		 * Multiplies this vector by the given normal matrix and normalizes
		 * the result.
		 *
		 * @param {Matrix3} m - The normal matrix.
		 * @return {Vector3} A reference to this vector.
		 */ applyNormalMatrix(m) {
	        return this.applyMatrix3(m).normalize();
	    }
	    /**
		 * Multiplies this vector (with an implicit 1 in the 4th dimension) by m, and
		 * divides by perspective.
		 *
		 * @param {Matrix4} m - The matrix to apply.
		 * @return {Vector3} A reference to this vector.
		 */ applyMatrix4(m) {
	        const x = this.x, y = this.y, 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;
	    }
	    /**
		 * Applies the given Quaternion to this vector.
		 *
		 * @param {Quaternion} q - The Quaternion.
		 * @return {Vector3} A reference to this vector.
		 */ applyQuaternion(q) {
	        // quaternion q is assumed to have unit length
	        const vx = this.x, vy = this.y, vz = this.z;
	        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
	        // t = 2 * cross( q.xyz, v );
	        const tx = 2 * (qy * vz - qz * vy);
	        const ty = 2 * (qz * vx - qx * vz);
	        const tz = 2 * (qx * vy - qy * vx);
	        // v + q.w * t + cross( q.xyz, t );
	        this.x = vx + qw * tx + qy * tz - qz * ty;
	        this.y = vy + qw * ty + qz * tx - qx * tz;
	        this.z = vz + qw * tz + qx * ty - qy * tx;
	        return this;
	    }
	    /**
		 * Projects this vector from world space into the camera's normalized
		 * device coordinate (NDC) space.
		 *
		 * @param {Camera} camera - The camera.
		 * @return {Vector3} A reference to this vector.
		 */ project(camera) {
	        return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
	    }
	    /**
		 * Unprojects this vector from the camera's normalized device coordinate (NDC)
		 * space into world space.
		 *
		 * @param {Camera} camera - The camera.
		 * @return {Vector3} A reference to this vector.
		 */ unproject(camera) {
	        return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
	    }
	    /**
		 * Transforms the direction of this vector by a matrix (the upper left 3 x 3
		 * subset of the given 4x4 matrix and then normalizes the result.
		 *
		 * @param {Matrix4} m - The matrix.
		 * @return {Vector3} A reference to this vector.
		 */ transformDirection(m) {
	        // input: THREE.Matrix4 affine matrix
	        // vector interpreted as a direction
	        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();
	    }
	    /**
		 * Divides this instance by the given vector.
		 *
		 * @param {Vector3} v - The vector to divide.
		 * @return {Vector3} A reference to this vector.
		 */ divide(v) {
	        this.x /= v.x;
	        this.y /= v.y;
	        this.z /= v.z;
	        return this;
	    }
	    /**
		 * Divides this vector by the given scalar.
		 *
		 * @param {number} scalar - The scalar to divide.
		 * @return {Vector3} A reference to this vector.
		 */ divideScalar(scalar) {
	        return this.multiplyScalar(1 / scalar);
	    }
	    /**
		 * If this vector's x, y or z value is greater than the given vector's x, y or z
		 * value, replace that value with the corresponding min value.
		 *
		 * @param {Vector3} v - The vector.
		 * @return {Vector3} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * If this vector's x, y or z value is less than the given vector's x, y or z
		 * value, replace that value with the corresponding max value.
		 *
		 * @param {Vector3} v - The vector.
		 * @return {Vector3} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * If this vector's x, y or z value is greater than the max vector's x, y or z
		 * value, it is replaced by the corresponding value.
		 * If this vector's x, y or z value is less than the min vector's x, y or z value,
		 * it is replaced by the corresponding value.
		 *
		 * @param {Vector3} min - The minimum x, y and z values.
		 * @param {Vector3} max - The maximum x, y and z values in the desired range.
		 * @return {Vector3} A reference to this vector.
		 */ clamp(min, max) {
	        // assumes min < max, componentwise
	        this.x = clamp$1(this.x, min.x, max.x);
	        this.y = clamp$1(this.y, min.y, max.y);
	        this.z = clamp$1(this.z, min.z, max.z);
	        return this;
	    }
	    /**
		 * If this vector's x, y or z values are greater than the max value, they are
		 * replaced by the max value.
		 * If this vector's x, y or z values are less than the min value, they are
		 * replaced by the min value.
		 *
		 * @param {number} minVal - The minimum value the components will be clamped to.
		 * @param {number} maxVal - The maximum value the components will be clamped to.
		 * @return {Vector3} A reference to this vector.
		 */ clampScalar(minVal, maxVal) {
	        this.x = clamp$1(this.x, minVal, maxVal);
	        this.y = clamp$1(this.y, minVal, maxVal);
	        this.z = clamp$1(this.z, minVal, maxVal);
	        return this;
	    }
	    /**
		 * If this vector's length is greater than the max value, it is replaced by
		 * the max value.
		 * If this vector's length is less than the min value, it is replaced by the
		 * min value.
		 *
		 * @param {number} min - The minimum value the vector length will be clamped to.
		 * @param {number} max - The maximum value the vector length will be clamped to.
		 * @return {Vector3} A reference to this vector.
		 */ clampLength(min, max) {
	        const length = this.length();
	        return this.divideScalar(length || 1).multiplyScalar(clamp$1(length, min, max));
	    }
	    /**
		 * The components of this vector are rounded down to the nearest integer value.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ floor() {
	        this.x = Math.floor(this.x);
	        this.y = Math.floor(this.y);
	        this.z = Math.floor(this.z);
	        return this;
	    }
	    /**
		 * The components of this vector are rounded up to the nearest integer value.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ ceil() {
	        this.x = Math.ceil(this.x);
	        this.y = Math.ceil(this.y);
	        this.z = Math.ceil(this.z);
	        return this;
	    }
	    /**
		 * The components of this vector are rounded to the nearest integer value
		 *
		 * @return {Vector3} A reference to this vector.
		 */ round() {
	        this.x = Math.round(this.x);
	        this.y = Math.round(this.y);
	        this.z = Math.round(this.z);
	        return this;
	    }
	    /**
		 * The components of this vector are rounded towards zero (up if negative,
		 * down if positive) to an integer value.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ roundToZero() {
	        this.x = Math.trunc(this.x);
	        this.y = Math.trunc(this.y);
	        this.z = Math.trunc(this.z);
	        return this;
	    }
	    /**
		 * Inverts this vector - i.e. sets x = -x, y = -y and z = -z.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ negate() {
	        this.x = -this.x;
	        this.y = -this.y;
	        this.z = -this.z;
	        return this;
	    }
	    /**
		 * Calculates the dot product of the given vector with this instance.
		 *
		 * @param {Vector3} v - The vector to compute the dot product with.
		 * @return {number} The result of the dot product.
		 */ dot(v) {
	        return this.x * v.x + this.y * v.y + this.z * v.z;
	    }
	    // TODO lengthSquared?
	    /**
		 * Computes the square of the Euclidean length (straight-line length) from
		 * (0, 0, 0) to (x, y, z). If you are comparing the lengths of vectors, you should
		 * compare the length squared instead as it is slightly more efficient to calculate.
		 *
		 * @return {number} The square length of this vector.
		 */ lengthSq() {
	        return this.x * this.x + this.y * this.y + this.z * this.z;
	    }
	    /**
		 * Computes the  Euclidean length (straight-line length) from (0, 0, 0) to (x, y, z).
		 *
		 * @return {number} The length of this vector.
		 */ length() {
	        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
	    }
	    /**
		 * Computes the Manhattan length of this vector.
		 *
		 * @return {number} The length of this vector.
		 */ manhattanLength() {
	        return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
	    }
	    /**
		 * Converts this vector to a unit vector - that is, sets it equal to a vector
		 * with the same direction as this one, but with a vector length of `1`.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ normalize() {
	        return this.divideScalar(this.length() || 1);
	    }
	    /**
		 * Sets this vector to a vector with the same direction as this one, but
		 * with the specified length.
		 *
		 * @param {number} length - The new length of this vector.
		 * @return {Vector3} A reference to this vector.
		 */ setLength(length) {
	        return this.normalize().multiplyScalar(length);
	    }
	    /**
		 * Linearly interpolates between the given vector and this instance, where
		 * alpha is the percent distance along the line - alpha = 0 will be this
		 * vector, and alpha = 1 will be the given one.
		 *
		 * @param {Vector3} v - The vector to interpolate towards.
		 * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
		 * @return {Vector3} A reference to this vector.
		 */ lerp(v, alpha) {
	        this.x += (v.x - this.x) * alpha;
	        this.y += (v.y - this.y) * alpha;
	        this.z += (v.z - this.z) * alpha;
	        return this;
	    }
	    /**
		 * Linearly interpolates between the given vectors, where alpha is the percent
		 * distance along the line - alpha = 0 will be first vector, and alpha = 1 will
		 * be the second one. The result is stored in this instance.
		 *
		 * @param {Vector3} v1 - The first vector.
		 * @param {Vector3} v2 - The second vector.
		 * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
		 * @return {Vector3} A reference to this vector.
		 */ 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;
	        return this;
	    }
	    /**
		 * Calculates the cross product of the given vector with this instance.
		 *
		 * @param {Vector3} v - The vector to compute the cross product with.
		 * @return {Vector3} The result of the cross product.
		 */ cross(v) {
	        return this.crossVectors(this, v);
	    }
	    /**
		 * Calculates the cross product of the given vectors and stores the result
		 * in this instance.
		 *
		 * @param {Vector3} a - The first vector.
		 * @param {Vector3} b - The second vector.
		 * @return {Vector3} A reference to this vector.
		 */ 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;
	    }
	    /**
		 * Projects this vector onto the given one.
		 *
		 * @param {Vector3} v - The vector to project to.
		 * @return {Vector3} A reference to this vector.
		 */ projectOnVector(v) {
	        const denominator = v.lengthSq();
	        if (denominator === 0) return this.set(0, 0, 0);
	        const scalar = v.dot(this) / denominator;
	        return this.copy(v).multiplyScalar(scalar);
	    }
	    /**
		 * Projects this vector onto a plane by subtracting this
		 * vector projected onto the plane's normal from this vector.
		 *
		 * @param {Vector3} planeNormal - The plane normal.
		 * @return {Vector3} A reference to this vector.
		 */ projectOnPlane(planeNormal) {
	        _vector$c.copy(this).projectOnVector(planeNormal);
	        return this.sub(_vector$c);
	    }
	    /**
		 * Reflects this vector off a plane orthogonal to the given normal vector.
		 *
		 * @param {Vector3} normal - The (normalized) normal vector.
		 * @return {Vector3} A reference to this vector.
		 */ reflect(normal) {
	        return this.sub(_vector$c.copy(normal).multiplyScalar(2 * this.dot(normal)));
	    }
	    /**
		 * Returns the angle between the given vector and this instance in radians.
		 *
		 * @param {Vector3} v - The vector to compute the angle with.
		 * @return {number} The angle in radians.
		 */ angleTo(v) {
	        const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
	        if (denominator === 0) return Math.PI / 2;
	        const theta = this.dot(v) / denominator;
	        // clamp, to handle numerical problems
	        return Math.acos(clamp$1(theta, -1, 1));
	    }
	    /**
		 * Computes the distance from the given vector to this instance.
		 *
		 * @param {Vector3} v - The vector to compute the distance to.
		 * @return {number} The distance.
		 */ distanceTo(v) {
	        return Math.sqrt(this.distanceToSquared(v));
	    }
	    /**
		 * Computes the squared distance from the given vector to this instance.
		 * If you are just comparing the distance with another distance, you should compare
		 * the distance squared instead as it is slightly more efficient to calculate.
		 *
		 * @param {Vector3} v - The vector to compute the squared distance to.
		 * @return {number} The squared distance.
		 */ 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;
	    }
	    /**
		 * Computes the Manhattan distance from the given vector to this instance.
		 *
		 * @param {Vector3} v - The vector to compute the Manhattan distance to.
		 * @return {number} The Manhattan distance.
		 */ manhattanDistanceTo(v) {
	        return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
	    }
	    /**
		 * Sets the vector components from the given spherical coordinates.
		 *
		 * @param {Spherical} s - The spherical coordinates.
		 * @return {Vector3} A reference to this vector.
		 */ setFromSpherical(s) {
	        return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
	    }
	    /**
		 * Sets the vector components from the given spherical coordinates.
		 *
		 * @param {number} radius - The radius.
		 * @param {number} phi - The phi angle in radians.
		 * @param {number} theta - The theta angle in radians.
		 * @return {Vector3} A reference to this vector.
		 */ setFromSphericalCoords(radius, phi, theta) {
	        const sinPhiRadius = Math.sin(phi) * radius;
	        this.x = sinPhiRadius * Math.sin(theta);
	        this.y = Math.cos(phi) * radius;
	        this.z = sinPhiRadius * Math.cos(theta);
	        return this;
	    }
	    /**
		 * Sets the vector components from the given cylindrical coordinates.
		 *
		 * @param {Cylindrical} c - The cylindrical coordinates.
		 * @return {Vector3} A reference to this vector.
		 */ setFromCylindrical(c) {
	        return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
	    }
	    /**
		 * Sets the vector components from the given cylindrical coordinates.
		 *
		 * @param {number} radius - The radius.
		 * @param {number} theta - The theta angle in radians.
		 * @param {number} y - The y value.
		 * @return {Vector3} A reference to this vector.
		 */ setFromCylindricalCoords(radius, theta, y) {
	        this.x = radius * Math.sin(theta);
	        this.y = y;
	        this.z = radius * Math.cos(theta);
	        return this;
	    }
	    /**
		 * Sets the vector components to the position elements of the
		 * given transformation matrix.
		 *
		 * @param {Matrix4} m - The 4x4 matrix.
		 * @return {Vector3} A reference to this vector.
		 */ setFromMatrixPosition(m) {
	        const e = m.elements;
	        this.x = e[12];
	        this.y = e[13];
	        this.z = e[14];
	        return this;
	    }
	    /**
		 * Sets the vector components to the scale elements of the
		 * given transformation matrix.
		 *
		 * @param {Matrix4} m - The 4x4 matrix.
		 * @return {Vector3} A reference to this vector.
		 */ setFromMatrixScale(m) {
	        const sx = this.setFromMatrixColumn(m, 0).length();
	        const sy = this.setFromMatrixColumn(m, 1).length();
	        const sz = this.setFromMatrixColumn(m, 2).length();
	        this.x = sx;
	        this.y = sy;
	        this.z = sz;
	        return this;
	    }
	    /**
		 * Sets the vector components from the specified matrix column.
		 *
		 * @param {Matrix4} m - The 4x4 matrix.
		 * @param {number} index - The column index.
		 * @return {Vector3} A reference to this vector.
		 */ setFromMatrixColumn(m, index) {
	        return this.fromArray(m.elements, index * 4);
	    }
	    /**
		 * Sets the vector components from the specified matrix column.
		 *
		 * @param {Matrix3} m - The 3x3 matrix.
		 * @param {number} index - The column index.
		 * @return {Vector3} A reference to this vector.
		 */ setFromMatrix3Column(m, index) {
	        return this.fromArray(m.elements, index * 3);
	    }
	    /**
		 * Sets the vector components from the given Euler angles.
		 *
		 * @param {Euler} e - The Euler angles to set.
		 * @return {Vector3} A reference to this vector.
		 */ setFromEuler(e) {
	        this.x = e._x;
	        this.y = e._y;
	        this.z = e._z;
	        return this;
	    }
	    /**
		 * Sets the vector components from the RGB components of the
		 * given color.
		 *
		 * @param {Color} c - The color to set.
		 * @return {Vector3} A reference to this vector.
		 */ setFromColor(c) {
	        this.x = c.r;
	        this.y = c.g;
	        this.z = c.b;
	        return this;
	    }
	    /**
		 * Returns `true` if this vector is equal with the given one.
		 *
		 * @param {Vector3} v - The vector to test for equality.
		 * @return {boolean} Whether this vector is equal with the given one.
		 */ equals(v) {
	        return v.x === this.x && v.y === this.y && v.z === this.z;
	    }
	    /**
		 * Sets this vector's x value to be `array[ offset ]`, y value to be `array[ offset + 1 ]`
		 * and z value to be `array[ offset + 2 ]`.
		 *
		 * @param {Array<number>} array - An array holding the vector component values.
		 * @param {number} [offset=0] - The offset into the array.
		 * @return {Vector3} A reference to this vector.
		 */ fromArray(array, offset = 0) {
	        this.x = array[offset];
	        this.y = array[offset + 1];
	        this.z = array[offset + 2];
	        return this;
	    }
	    /**
		 * Writes the components of this vector to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the vector components.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The vector components.
		 */ toArray(array = [], offset = 0) {
	        array[offset] = this.x;
	        array[offset + 1] = this.y;
	        array[offset + 2] = this.z;
	        return array;
	    }
	    /**
		 * Sets the components of this vector from the given buffer attribute.
		 *
		 * @param {BufferAttribute} attribute - The buffer attribute holding vector data.
		 * @param {number} index - The index into the attribute.
		 * @return {Vector3} A reference to this vector.
		 */ fromBufferAttribute(attribute, index) {
	        this.x = attribute.getX(index);
	        this.y = attribute.getY(index);
	        this.z = attribute.getZ(index);
	        return this;
	    }
	    /**
		 * Sets each component of this vector to a pseudo-random value between `0` and
		 * `1`, excluding `1`.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ random() {
	        this.x = Math.random();
	        this.y = Math.random();
	        this.z = Math.random();
	        return this;
	    }
	    /**
		 * Sets this vector to a uniformly random point on a unit sphere.
		 *
		 * @return {Vector3} A reference to this vector.
		 */ randomDirection() {
	        // https://mathworld.wolfram.com/SpherePointPicking.html
	        const theta = Math.random() * Math.PI * 2;
	        const u = Math.random() * 2 - 1;
	        const c = Math.sqrt(1 - u * u);
	        this.x = c * Math.cos(theta);
	        this.y = u;
	        this.z = c * Math.sin(theta);
	        return this;
	    }
	    *[Symbol.iterator]() {
	        yield this.x;
	        yield this.y;
	        yield this.z;
	    }
	    /**
		 * Constructs a new 3D vector.
		 *
		 * @param {number} [x=0] - The x value of this vector.
		 * @param {number} [y=0] - The y value of this vector.
		 * @param {number} [z=0] - The z value of this vector.
		 */ constructor(x = 0, y = 0, z = 0){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ Vector3.prototype.isVector3 = true;
	        /**
			 * The x value of this vector.
			 *
			 * @type {number}
			 */ this.x = x;
	        /**
			 * The y value of this vector.
			 *
			 * @type {number}
			 */ this.y = y;
	        /**
			 * The z value of this vector.
			 *
			 * @type {number}
			 */ this.z = z;
	    }
	}
	const _vector$c = /*@__PURE__*/ new Vector3();
	const _quaternion$4 = /*@__PURE__*/ new Quaternion();
	/**
	 * Represents an axis-aligned bounding box (AABB) in 3D space.
	 */ class Box3 {
	    /**
		 * Sets the lower and upper boundaries of this box.
		 * Please note that this method only copies the values from the given objects.
		 *
		 * @param {Vector3} min - The lower boundary of the box.
		 * @param {Vector3} max - The upper boundary of the box.
		 * @return {Box3} A reference to this bounding box.
		 */ set(min, max) {
	        this.min.copy(min);
	        this.max.copy(max);
	        return this;
	    }
	    /**
		 * Sets the upper and lower bounds of this box so it encloses the position data
		 * in the given array.
		 *
		 * @param {Array<number>} array - An array holding 3D position data.
		 * @return {Box3} A reference to this bounding box.
		 */ setFromArray(array) {
	        this.makeEmpty();
	        for(let i = 0, il = array.length; i < il; i += 3){
	            this.expandByPoint(_vector$b.fromArray(array, i));
	        }
	        return this;
	    }
	    /**
		 * Sets the upper and lower bounds of this box so it encloses the position data
		 * in the given buffer attribute.
		 *
		 * @param {BufferAttribute} attribute - A buffer attribute holding 3D position data.
		 * @return {Box3} A reference to this bounding box.
		 */ setFromBufferAttribute(attribute) {
	        this.makeEmpty();
	        for(let i = 0, il = attribute.count; i < il; i++){
	            this.expandByPoint(_vector$b.fromBufferAttribute(attribute, i));
	        }
	        return this;
	    }
	    /**
		 * Sets the upper and lower bounds of this box so it encloses the position data
		 * in the given array.
		 *
		 * @param {Array<Vector3>} points - An array holding 3D position data as instances of {@link Vector3}.
		 * @return {Box3} A reference to this bounding box.
		 */ setFromPoints(points) {
	        this.makeEmpty();
	        for(let i = 0, il = points.length; i < il; i++){
	            this.expandByPoint(points[i]);
	        }
	        return this;
	    }
	    /**
		 * Centers this box on the given center vector and sets this box's width, height and
		 * depth to the given size values.
		 *
		 * @param {Vector3} center - The center of the box.
		 * @param {Vector3} size - The x, y and z dimensions of the box.
		 * @return {Box3} A reference to this bounding box.
		 */ setFromCenterAndSize(center, size) {
	        const halfSize = _vector$b.copy(size).multiplyScalar(0.5);
	        this.min.copy(center).sub(halfSize);
	        this.max.copy(center).add(halfSize);
	        return this;
	    }
	    /**
		 * Computes the world-axis-aligned bounding box for the given 3D object
		 * (including its children), accounting for the object's, and children's,
		 * world transforms. The function may result in a larger box than strictly necessary.
		 *
		 * @param {Object3D} object - The 3D object to compute the bounding box for.
		 * @param {boolean} [precise=false] - If set to `true`, the method computes the smallest
		 * world-axis-aligned bounding box at the expense of more computation.
		 * @return {Box3} A reference to this bounding box.
		 */ setFromObject(object, precise = false) {
	        this.makeEmpty();
	        return this.expandByObject(object, precise);
	    }
	    /**
		 * Returns a new box with copied values from this instance.
		 *
		 * @return {Box3} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Copies the values of the given box to this instance.
		 *
		 * @param {Box3} box - The box to copy.
		 * @return {Box3} A reference to this bounding box.
		 */ copy(box) {
	        this.min.copy(box.min);
	        this.max.copy(box.max);
	        return this;
	    }
	    /**
		 * Makes this box empty which means in encloses a zero space in 3D.
		 *
		 * @return {Box3} A reference to this bounding box.
		 */ makeEmpty() {
	        this.min.x = this.min.y = this.min.z = +Infinity;
	        this.max.x = this.max.y = this.max.z = -Infinity;
	        return this;
	    }
	    /**
		 * Returns true if this box includes zero points within its bounds.
		 * Note that a box with equal lower and upper bounds still includes one
		 * point, the one both bounds share.
		 *
		 * @return {boolean} Whether this box is empty or not.
		 */ isEmpty() {
	        // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
	        return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z;
	    }
	    /**
		 * Returns the center point of this box.
		 *
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The center point.
		 */ getCenter(target) {
	        return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5);
	    }
	    /**
		 * Returns the dimensions of this box.
		 *
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The size.
		 */ getSize(target) {
	        return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min);
	    }
	    /**
		 * Expands the boundaries of this box to include the given point.
		 *
		 * @param {Vector3} point - The point that should be included by the bounding box.
		 * @return {Box3} A reference to this bounding box.
		 */ expandByPoint(point) {
	        this.min.min(point);
	        this.max.max(point);
	        return this;
	    }
	    /**
		 * Expands this box equilaterally by the given vector. The width of this
		 * box will be expanded by the x component of the vector in both
		 * directions. The height of this box will be expanded by the y component of
		 * the vector in both directions. The depth of this box will be
		 * expanded by the z component of the vector in both directions.
		 *
		 * @param {Vector3} vector - The vector that should expand the bounding box.
		 * @return {Box3} A reference to this bounding box.
		 */ expandByVector(vector) {
	        this.min.sub(vector);
	        this.max.add(vector);
	        return this;
	    }
	    /**
		 * Expands each dimension of the box by the given scalar. If negative, the
		 * dimensions of the box will be contracted.
		 *
		 * @param {number} scalar - The scalar value that should expand the bounding box.
		 * @return {Box3} A reference to this bounding box.
		 */ expandByScalar(scalar) {
	        this.min.addScalar(-scalar);
	        this.max.addScalar(scalar);
	        return this;
	    }
	    /**
		 * Expands the boundaries of this box to include the given 3D object and
		 * its children, accounting for the object's, and children's, world
		 * transforms. The function may result in a larger box than strictly
		 * necessary (unless the precise parameter is set to true).
		 *
		 * @param {Object3D} object - The 3D object that should expand the bounding box.
		 * @param {boolean} precise - If set to `true`, the method expands the bounding box
		 * as little as necessary at the expense of more computation.
		 * @return {Box3} A reference to this bounding box.
		 */ expandByObject(object, precise = false) {
	        // Computes the world-axis-aligned bounding box of an object (including its children),
	        // accounting for both the object's, and children's, world transforms
	        object.updateWorldMatrix(false, false);
	        const geometry = object.geometry;
	        if (geometry !== undefined) {
	            const positionAttribute = geometry.getAttribute('position');
	            // precise AABB computation based on vertex data requires at least a position attribute.
	            // instancing isn't supported so far and uses the normal (conservative) code path.
	            if (precise === true && positionAttribute !== undefined && object.isInstancedMesh !== true) {
	                for(let i = 0, l = positionAttribute.count; i < l; i++){
	                    if (object.isMesh === true) {
	                        object.getVertexPosition(i, _vector$b);
	                    } else {
	                        _vector$b.fromBufferAttribute(positionAttribute, i);
	                    }
	                    _vector$b.applyMatrix4(object.matrixWorld);
	                    this.expandByPoint(_vector$b);
	                }
	            } else {
	                if (object.boundingBox !== undefined) {
	                    // object-level bounding box
	                    if (object.boundingBox === null) {
	                        object.computeBoundingBox();
	                    }
	                    _box$4.copy(object.boundingBox);
	                } else {
	                    // geometry-level bounding box
	                    if (geometry.boundingBox === null) {
	                        geometry.computeBoundingBox();
	                    }
	                    _box$4.copy(geometry.boundingBox);
	                }
	                _box$4.applyMatrix4(object.matrixWorld);
	                this.union(_box$4);
	            }
	        }
	        const children = object.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            this.expandByObject(children[i], precise);
	        }
	        return this;
	    }
	    /**
		 * Returns `true` if the given point lies within or on the boundaries of this box.
		 *
		 * @param {Vector3} point - The point to test.
		 * @return {boolean} Whether the bounding box contains the given point or not.
		 */ 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;
	    }
	    /**
		 * Returns `true` if this bounding box includes the entirety of the given bounding box.
		 * If this box and the given one are identical, this function also returns `true`.
		 *
		 * @param {Box3} box - The bounding box to test.
		 * @return {boolean} Whether the bounding box contains the given bounding box or not.
		 */ 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;
	    }
	    /**
		 * Returns a point as a proportion of this box's width, height and depth.
		 *
		 * @param {Vector3} point - A point in 3D space.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} A point as a proportion of this box's width, height and depth.
		 */ getParameter(point, target) {
	        // This can potentially have a divide by zero if the box
	        // has a size dimension of 0.
	        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));
	    }
	    /**
		 * Returns `true` if the given bounding box intersects with this bounding box.
		 *
		 * @param {Box3} box - The bounding box to test.
		 * @return {boolean} Whether the given bounding box intersects with this bounding box.
		 */ intersectsBox(box) {
	        // using 6 splitting planes to rule out intersections.
	        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;
	    }
	    /**
		 * Returns `true` if the given bounding sphere intersects with this bounding box.
		 *
		 * @param {Sphere} sphere - The bounding sphere to test.
		 * @return {boolean} Whether the given bounding sphere intersects with this bounding box.
		 */ intersectsSphere(sphere) {
	        // Find the point on the AABB closest to the sphere center.
	        this.clampPoint(sphere.center, _vector$b);
	        // If that point is inside the sphere, the AABB and sphere intersect.
	        return _vector$b.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius;
	    }
	    /**
		 * Returns `true` if the given plane intersects with this bounding box.
		 *
		 * @param {Plane} plane - The plane to test.
		 * @return {boolean} Whether the given plane intersects with this bounding box.
		 */ intersectsPlane(plane) {
	        // We compute the minimum and maximum dot product values. If those values
	        // are on the same side (back or front) of the plane, then there is no intersection.
	        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;
	    }
	    /**
		 * Returns `true` if the given triangle intersects with this bounding box.
		 *
		 * @param {Triangle} triangle - The triangle to test.
		 * @return {boolean} Whether the given triangle intersects with this bounding box.
		 */ intersectsTriangle(triangle) {
	        if (this.isEmpty()) {
	            return false;
	        }
	        // compute box center and extents
	        this.getCenter(_center);
	        _extents.subVectors(this.max, _center);
	        // translate triangle to aabb origin
	        _v0$2.subVectors(triangle.a, _center);
	        _v1$7.subVectors(triangle.b, _center);
	        _v2$4.subVectors(triangle.c, _center);
	        // compute edge vectors for triangle
	        _f0.subVectors(_v1$7, _v0$2);
	        _f1.subVectors(_v2$4, _v1$7);
	        _f2.subVectors(_v0$2, _v2$4);
	        // test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
	        // make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
	        // axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
	        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$4, _extents)) {
	            return false;
	        }
	        // test 3 face normals from the aabb
	        axes = [
	            1,
	            0,
	            0,
	            0,
	            1,
	            0,
	            0,
	            0,
	            1
	        ];
	        if (!satForAxes(axes, _v0$2, _v1$7, _v2$4, _extents)) {
	            return false;
	        }
	        // finally testing the face normal of the triangle
	        // use already existing triangle edge vectors here
	        _triangleNormal.crossVectors(_f0, _f1);
	        axes = [
	            _triangleNormal.x,
	            _triangleNormal.y,
	            _triangleNormal.z
	        ];
	        return satForAxes(axes, _v0$2, _v1$7, _v2$4, _extents);
	    }
	    /**
		 * Clamps the given point within the bounds of this box.
		 *
		 * @param {Vector3} point - The point to clamp.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The clamped point.
		 */ clampPoint(point, target) {
	        return target.copy(point).clamp(this.min, this.max);
	    }
	    /**
		 * Returns the euclidean distance from any edge of this box to the specified point. If
		 * the given point lies inside of this box, the distance will be `0`.
		 *
		 * @param {Vector3} point - The point to compute the distance to.
		 * @return {number} The euclidean distance.
		 */ distanceToPoint(point) {
	        return this.clampPoint(point, _vector$b).distanceTo(point);
	    }
	    /**
		 * Returns a bounding sphere that encloses this bounding box.
		 *
		 * @param {Sphere} target - The target sphere that is used to store the method's result.
		 * @return {Sphere} The bounding sphere that encloses this bounding box.
		 */ getBoundingSphere(target) {
	        if (this.isEmpty()) {
	            target.makeEmpty();
	        } else {
	            this.getCenter(target.center);
	            target.radius = this.getSize(_vector$b).length() * 0.5;
	        }
	        return target;
	    }
	    /**
		 * Computes the intersection of this bounding box and the given one, setting the upper
		 * bound of this box to the lesser of the two boxes' upper bounds and the
		 * lower bound of this box to the greater of the two boxes' lower bounds. If
		 * there's no overlap, makes this box empty.
		 *
		 * @param {Box3} box - The bounding box to intersect with.
		 * @return {Box3} A reference to this bounding box.
		 */ intersect(box) {
	        this.min.max(box.min);
	        this.max.min(box.max);
	        // ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
	        if (this.isEmpty()) this.makeEmpty();
	        return this;
	    }
	    /**
		 * Computes the union of this box and another and the given one, setting the upper
		 * bound of this box to the greater of the two boxes' upper bounds and the
		 * lower bound of this box to the lesser of the two boxes' lower bounds.
		 *
		 * @param {Box3} box - The bounding box that will be unioned with this instance.
		 * @return {Box3} A reference to this bounding box.
		 */ union(box) {
	        this.min.min(box.min);
	        this.max.max(box.max);
	        return this;
	    }
	    /**
		 * Transforms this bounding box by the given 4x4 transformation matrix.
		 *
		 * @param {Matrix4} matrix - The transformation matrix.
		 * @return {Box3} A reference to this bounding box.
		 */ applyMatrix4(matrix) {
	        // transform of empty box is an empty box.
	        if (this.isEmpty()) return this;
	        // NOTE: I am using a binary pattern to specify all 2^3 combinations below
	        _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;
	    }
	    /**
		 * Adds the given offset to both the upper and lower bounds of this bounding box,
		 * effectively moving it in 3D space.
		 *
		 * @param {Vector3} offset - The offset that should be used to translate the bounding box.
		 * @return {Box3} A reference to this bounding box.
		 */ translate(offset) {
	        this.min.add(offset);
	        this.max.add(offset);
	        return this;
	    }
	    /**
		 * Returns `true` if this bounding box is equal with the given one.
		 *
		 * @param {Box3} box - The box to test for equality.
		 * @return {boolean} Whether this bounding box is equal with the given one.
		 */ equals(box) {
	        return box.min.equals(this.min) && box.max.equals(this.max);
	    }
	    /**
		 * Constructs a new bounding box.
		 *
		 * @param {Vector3} [min=(Infinity,Infinity,Infinity)] - A vector representing the lower boundary of the box.
		 * @param {Vector3} [max=(-Infinity,-Infinity,-Infinity)] - A vector representing the upper boundary of the box.
		 */ constructor(min = new Vector3(+Infinity, +Infinity, +Infinity), max = new Vector3(-Infinity, -Infinity, -Infinity)){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isBox3 = true;
	        /**
			 * The lower boundary of the box.
			 *
			 * @type {Vector3}
			 */ this.min = min;
	        /**
			 * The upper boundary of the box.
			 *
			 * @type {Vector3}
			 */ this.max = 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$4 = /*@__PURE__*/ new Box3();
	// triangle centered vertices
	const _v0$2 = /*@__PURE__*/ new Vector3();
	const _v1$7 = /*@__PURE__*/ new Vector3();
	const _v2$4 = /*@__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){
	        _testAxis.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$3 = /*@__PURE__*/ new Box3();
	const _v1$6 = /*@__PURE__*/ new Vector3();
	const _v2$3 = /*@__PURE__*/ new Vector3();
	/**
	 * An analytical 3D sphere defined by a center and radius. This class is mainly
	 * used as a Bounding Sphere for 3D objects.
	 */ class Sphere {
	    /**
		 * Sets the sphere's components by copying the given values.
		 *
		 * @param {Vector3} center - The center.
		 * @param {number} radius - The radius.
		 * @return {Sphere} A reference to this sphere.
		 */ set(center, radius) {
	        this.center.copy(center);
	        this.radius = radius;
	        return this;
	    }
	    /**
		 * Computes the minimum bounding sphere for list of points.
		 * If the optional center point is given, it is used as the sphere's
		 * center. Otherwise, the center of the axis-aligned bounding box
		 * encompassing the points is calculated.
		 *
		 * @param {Array<Vector3>} points - A list of points in 3D space.
		 * @param {Vector3} [optionalCenter] - The center of the sphere.
		 * @return {Sphere} A reference to this sphere.
		 */ setFromPoints(points, optionalCenter) {
	        const center = this.center;
	        if (optionalCenter !== undefined) {
	            center.copy(optionalCenter);
	        } else {
	            _box$3.setFromPoints(points).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;
	    }
	    /**
		 * Copies the values of the given sphere to this instance.
		 *
		 * @param {Sphere} sphere - The sphere to copy.
		 * @return {Sphere} A reference to this sphere.
		 */ copy(sphere) {
	        this.center.copy(sphere.center);
	        this.radius = sphere.radius;
	        return this;
	    }
	    /**
		 * Returns `true` if the sphere is empty (the radius set to a negative number).
		 *
		 * Spheres with a radius of `0` contain only their center point and are not
		 * considered to be empty.
		 *
		 * @return {boolean} Whether this sphere is empty or not.
		 */ isEmpty() {
	        return this.radius < 0;
	    }
	    /**
		 * Makes this sphere empty which means in encloses a zero space in 3D.
		 *
		 * @return {Sphere} A reference to this sphere.
		 */ makeEmpty() {
	        this.center.set(0, 0, 0);
	        this.radius = -1;
	        return this;
	    }
	    /**
		 * Returns `true` if this sphere contains the given point inclusive of
		 * the surface of the sphere.
		 *
		 * @param {Vector3} point - The point to check.
		 * @return {boolean} Whether this sphere contains the given point or not.
		 */ containsPoint(point) {
	        return point.distanceToSquared(this.center) <= this.radius * this.radius;
	    }
	    /**
		 * Returns the closest distance from the boundary of the sphere to the
		 * given point. If the sphere contains the point, the distance will
		 * be negative.
		 *
		 * @param {Vector3} point - The point to compute the distance to.
		 * @return {number} The distance to the point.
		 */ distanceToPoint(point) {
	        return point.distanceTo(this.center) - this.radius;
	    }
	    /**
		 * Returns `true` if this sphere intersects with the given one.
		 *
		 * @param {Sphere} sphere - The sphere to test.
		 * @return {boolean} Whether this sphere intersects with the given one or not.
		 */ intersectsSphere(sphere) {
	        const radiusSum = this.radius + sphere.radius;
	        return sphere.center.distanceToSquared(this.center) <= radiusSum * radiusSum;
	    }
	    /**
		 * Returns `true` if this sphere intersects with the given box.
		 *
		 * @param {Box3} box - The box to test.
		 * @return {boolean} Whether this sphere intersects with the given box or not.
		 */ intersectsBox(box) {
	        return box.intersectsSphere(this);
	    }
	    /**
		 * Returns `true` if this sphere intersects with the given plane.
		 *
		 * @param {Plane} plane - The plane to test.
		 * @return {boolean} Whether this sphere intersects with the given plane or not.
		 */ intersectsPlane(plane) {
	        return Math.abs(plane.distanceToPoint(this.center)) <= this.radius;
	    }
	    /**
		 * Clamps a point within the sphere. If the point is outside the sphere, it
		 * will clamp it to the closest point on the edge of the sphere. Points
		 * already inside the sphere will not be affected.
		 *
		 * @param {Vector3} point - The plane to clamp.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The clamped point.
		 */ clampPoint(point, target) {
	        const deltaLengthSq = this.center.distanceToSquared(point);
	        target.copy(point);
	        if (deltaLengthSq > this.radius * this.radius) {
	            target.sub(this.center).normalize();
	            target.multiplyScalar(this.radius).add(this.center);
	        }
	        return target;
	    }
	    /**
		 * Returns a bounding box that encloses this sphere.
		 *
		 * @param {Box3} target - The target box that is used to store the method's result.
		 * @return {Box3} The bounding box that encloses this sphere.
		 */ getBoundingBox(target) {
	        if (this.isEmpty()) {
	            // Empty sphere produces empty bounding box
	            target.makeEmpty();
	            return target;
	        }
	        target.set(this.center, this.center);
	        target.expandByScalar(this.radius);
	        return target;
	    }
	    /**
		 * Transforms this sphere with the given 4x4 transformation matrix.
		 *
		 * @param {Matrix4} matrix - The transformation matrix.
		 * @return {Sphere} A reference to this sphere.
		 */ applyMatrix4(matrix) {
	        this.center.applyMatrix4(matrix);
	        this.radius = this.radius * matrix.getMaxScaleOnAxis();
	        return this;
	    }
	    /**
		 * Translates the sphere's center by the given offset.
		 *
		 * @param {Vector3} offset - The offset.
		 * @return {Sphere} A reference to this sphere.
		 */ translate(offset) {
	        this.center.add(offset);
	        return this;
	    }
	    /**
		 * Expands the boundaries of this sphere to include the given point.
		 *
		 * @param {Vector3} point - The point to include.
		 * @return {Sphere} A reference to this sphere.
		 */ expandByPoint(point) {
	        if (this.isEmpty()) {
	            this.center.copy(point);
	            this.radius = 0;
	            return this;
	        }
	        _v1$6.subVectors(point, this.center);
	        const lengthSq = _v1$6.lengthSq();
	        if (lengthSq > this.radius * this.radius) {
	            // calculate the minimal sphere
	            const length = Math.sqrt(lengthSq);
	            const delta = (length - this.radius) * 0.5;
	            this.center.addScaledVector(_v1$6, delta / length);
	            this.radius += delta;
	        }
	        return this;
	    }
	    /**
		 * Expands this sphere to enclose both the original sphere and the given sphere.
		 *
		 * @param {Sphere} sphere - The sphere to include.
		 * @return {Sphere} A reference to this sphere.
		 */ union(sphere) {
	        if (sphere.isEmpty()) {
	            return this;
	        }
	        if (this.isEmpty()) {
	            this.copy(sphere);
	            return this;
	        }
	        if (this.center.equals(sphere.center) === true) {
	            this.radius = Math.max(this.radius, sphere.radius);
	        } else {
	            _v2$3.subVectors(sphere.center, this.center).setLength(sphere.radius);
	            this.expandByPoint(_v1$6.copy(sphere.center).add(_v2$3));
	            this.expandByPoint(_v1$6.copy(sphere.center).sub(_v2$3));
	        }
	        return this;
	    }
	    /**
		 * Returns `true` if this sphere is equal with the given one.
		 *
		 * @param {Sphere} sphere - The sphere to test for equality.
		 * @return {boolean} Whether this bounding sphere is equal with the given one.
		 */ equals(sphere) {
	        return sphere.center.equals(this.center) && sphere.radius === this.radius;
	    }
	    /**
		 * Returns a new sphere with copied values from this instance.
		 *
		 * @return {Sphere} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Constructs a new sphere.
		 *
		 * @param {Vector3} [center=(0,0,0)] - The center of the sphere
		 * @param {number} [radius=-1] - The radius of the sphere.
		 */ constructor(center = new Vector3(), radius = -1){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isSphere = true;
	        /**
			 * The center of the sphere
			 *
			 * @type {Vector3}
			 */ this.center = center;
	        /**
			 * The radius of the sphere.
			 *
			 * @type {number}
			 */ this.radius = radius;
	    }
	}
	const _vector$a = /*@__PURE__*/ new Vector3();
	const _segCenter = /*@__PURE__*/ new Vector3();
	const _segDir = /*@__PURE__*/ new Vector3();
	const _diff = /*@__PURE__*/ new Vector3();
	const _edge1 = /*@__PURE__*/ new Vector3();
	const _edge2 = /*@__PURE__*/ new Vector3();
	const _normal$1 = /*@__PURE__*/ new Vector3();
	/**
	 * A ray that emits from an origin in a certain direction. The class is used by
	 * {@link Raycaster} to assist with raycasting. Raycasting is used for
	 * mouse picking (working out what objects in the 3D space the mouse is over)
	 * amongst other things.
	 */ class Ray {
	    /**
		 * Sets the ray's components by copying the given values.
		 *
		 * @param {Vector3} origin - The origin.
		 * @param {Vector3} direction - The direction.
		 * @return {Ray} A reference to this ray.
		 */ set(origin, direction) {
	        this.origin.copy(origin);
	        this.direction.copy(direction);
	        return this;
	    }
	    /**
		 * Copies the values of the given ray to this instance.
		 *
		 * @param {Ray} ray - The ray to copy.
		 * @return {Ray} A reference to this ray.
		 */ copy(ray) {
	        this.origin.copy(ray.origin);
	        this.direction.copy(ray.direction);
	        return this;
	    }
	    /**
		 * Returns a vector that is located at a given distance along this ray.
		 *
		 * @param {number} t - The distance along the ray to retrieve a position for.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} A position on the ray.
		 */ at(t, target) {
	        return target.copy(this.origin).addScaledVector(this.direction, t);
	    }
	    /**
		 * Adjusts the direction of the ray to point at the given vector in world space.
		 *
		 * @param {Vector3} v - The target position.
		 * @return {Ray} A reference to this ray.
		 */ lookAt(v) {
	        this.direction.copy(v).sub(this.origin).normalize();
	        return this;
	    }
	    /**
		 * Shift the origin of this ray along its direction by the given distance.
		 *
		 * @param {number} t - The distance along the ray to interpolate.
		 * @return {Ray} A reference to this ray.
		 */ recast(t) {
	        this.origin.copy(this.at(t, _vector$a));
	        return this;
	    }
	    /**
		 * Returns the point along this ray that is closest to the given point.
		 *
		 * @param {Vector3} point - A point in 3D space to get the closet location on the ray for.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The closest point on this ray.
		 */ closestPointToPoint(point, target) {
	        target.subVectors(point, this.origin);
	        const directionDistance = target.dot(this.direction);
	        if (directionDistance < 0) {
	            return target.copy(this.origin);
	        }
	        return target.copy(this.origin).addScaledVector(this.direction, directionDistance);
	    }
	    /**
		 * Returns the distance of the closest approach between this ray and the given point.
		 *
		 * @param {Vector3} point - A point in 3D space to compute the distance to.
		 * @return {number} The distance.
		 */ distanceToPoint(point) {
	        return Math.sqrt(this.distanceSqToPoint(point));
	    }
	    /**
		 * Returns the squared distance of the closest approach between this ray and the given point.
		 *
		 * @param {Vector3} point - A point in 3D space to compute the distance to.
		 * @return {number} The squared distance.
		 */ distanceSqToPoint(point) {
	        const directionDistance = _vector$a.subVectors(point, this.origin).dot(this.direction);
	        // point behind the ray
	        if (directionDistance < 0) {
	            return this.origin.distanceToSquared(point);
	        }
	        _vector$a.copy(this.origin).addScaledVector(this.direction, directionDistance);
	        return _vector$a.distanceToSquared(point);
	    }
	    /**
		 * Returns the squared distance between this ray and the given line segment.
		 *
		 * @param {Vector3} v0 - The start point of the line segment.
		 * @param {Vector3} v1 - The end point of the line segment.
		 * @param {Vector3} [optionalPointOnRay] - When provided, it receives the point on this ray that is closest to the segment.
		 * @param {Vector3} [optionalPointOnSegment] - When provided, it receives the point on the line segment that is closest to this ray.
		 * @return {number} The squared distance.
		 */ distanceSqToSegment(v0, v1, optionalPointOnRay, optionalPointOnSegment) {
	        // from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteDistRaySegment.h
	        // It returns the min distance between the ray and the segment
	        // defined by v0 and v1
	        // It can also set two optional targets :
	        // - The closest point on the ray
	        // - The closest point on the segment
	        _segCenter.copy(v0).add(v1).multiplyScalar(0.5);
	        _segDir.copy(v1).sub(v0).normalize();
	        _diff.copy(this.origin).sub(_segCenter);
	        const segExtent = v0.distanceTo(v1) * 0.5;
	        const a01 = -this.direction.dot(_segDir);
	        const b0 = _diff.dot(this.direction);
	        const b1 = -_diff.dot(_segDir);
	        const c = _diff.lengthSq();
	        const det = Math.abs(1 - a01 * a01);
	        let s0, s1, sqrDist, extDet;
	        if (det > 0) {
	            // The ray and segment are not parallel.
	            s0 = a01 * b1 - b0;
	            s1 = a01 * b0 - b1;
	            extDet = segExtent * det;
	            if (s0 >= 0) {
	                if (s1 >= -extDet) {
	                    if (s1 <= extDet) {
	                        // region 0
	                        // Minimum at interior points of ray and segment.
	                        const invDet = 1 / det;
	                        s0 *= invDet;
	                        s1 *= invDet;
	                        sqrDist = s0 * (s0 + a01 * s1 + 2 * b0) + s1 * (a01 * s0 + s1 + 2 * b1) + c;
	                    } else {
	                        // region 1
	                        s1 = segExtent;
	                        s0 = Math.max(0, -(a01 * s1 + b0));
	                        sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
	                    }
	                } else {
	                    // region 5
	                    s1 = -segExtent;
	                    s0 = Math.max(0, -(a01 * s1 + b0));
	                    sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
	                }
	            } else {
	                if (s1 <= -extDet) {
	                    // region 4
	                    s0 = Math.max(0, -(-a01 * segExtent + b0));
	                    s1 = s0 > 0 ? -segExtent : Math.min(Math.max(-segExtent, -b1), segExtent);
	                    sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
	                } else if (s1 <= extDet) {
	                    // region 3
	                    s0 = 0;
	                    s1 = Math.min(Math.max(-segExtent, -b1), segExtent);
	                    sqrDist = s1 * (s1 + 2 * b1) + c;
	                } else {
	                    // region 2
	                    s0 = Math.max(0, -(a01 * segExtent + b0));
	                    s1 = s0 > 0 ? segExtent : Math.min(Math.max(-segExtent, -b1), segExtent);
	                    sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
	                }
	            }
	        } else {
	            // Ray and segment are parallel.
	            s1 = a01 > 0 ? -segExtent : segExtent;
	            s0 = Math.max(0, -(a01 * s1 + b0));
	            sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
	        }
	        if (optionalPointOnRay) {
	            optionalPointOnRay.copy(this.origin).addScaledVector(this.direction, s0);
	        }
	        if (optionalPointOnSegment) {
	            optionalPointOnSegment.copy(_segCenter).addScaledVector(_segDir, s1);
	        }
	        return sqrDist;
	    }
	    /**
		 * Intersects this ray with the given sphere, returning the intersection
		 * point or `null` if there is no intersection.
		 *
		 * @param {Sphere} sphere - The sphere to intersect.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The intersection point.
		 */ intersectSphere(sphere, target) {
	        _vector$a.subVectors(sphere.center, this.origin);
	        const tca = _vector$a.dot(this.direction);
	        const d2 = _vector$a.dot(_vector$a) - tca * tca;
	        const radius2 = sphere.radius * sphere.radius;
	        if (d2 > radius2) return null;
	        const thc = Math.sqrt(radius2 - d2);
	        // t0 = first intersect point - entrance on front of sphere
	        const t0 = tca - thc;
	        // t1 = second intersect point - exit point on back of sphere
	        const t1 = tca + thc;
	        // test to see if t1 is behind the ray - if so, return null
	        if (t1 < 0) return null;
	        // test to see if t0 is behind the ray:
	        // if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
	        // in order to always return an intersect point that is in front of the ray.
	        if (t0 < 0) return this.at(t1, target);
	        // else t0 is in front of the ray, so return the first collision point scaled by t0
	        return this.at(t0, target);
	    }
	    /**
		 * Returns `true` if this ray intersects with the given sphere.
		 *
		 * @param {Sphere} sphere - The sphere to intersect.
		 * @return {boolean} Whether this ray intersects with the given sphere or not.
		 */ intersectsSphere(sphere) {
	        return this.distanceSqToPoint(sphere.center) <= sphere.radius * sphere.radius;
	    }
	    /**
		 * Computes the distance from the ray's origin to the given plane. Returns `null` if the ray
		 * does not intersect with the plane.
		 *
		 * @param {Plane} plane - The plane to compute the distance to.
		 * @return {?number} Whether this ray intersects with the given sphere or not.
		 */ distanceToPlane(plane) {
	        const denominator = plane.normal.dot(this.direction);
	        if (denominator === 0) {
	            // line is coplanar, return origin
	            if (plane.distanceToPoint(this.origin) === 0) {
	                return 0;
	            }
	            // Null is preferable to undefined since undefined means.... it is undefined
	            return null;
	        }
	        const t = -(this.origin.dot(plane.normal) + plane.constant) / denominator;
	        // Return if the ray never intersects the plane
	        return t >= 0 ? t : null;
	    }
	    /**
		 * Intersects this ray with the given plane, returning the intersection
		 * point or `null` if there is no intersection.
		 *
		 * @param {Plane} plane - The plane to intersect.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The intersection point.
		 */ intersectPlane(plane, target) {
	        const t = this.distanceToPlane(plane);
	        if (t === null) {
	            return null;
	        }
	        return this.at(t, target);
	    }
	    /**
		 * Returns `true` if this ray intersects with the given plane.
		 *
		 * @param {Plane} plane - The plane to intersect.
		 * @return {boolean} Whether this ray intersects with the given plane or not.
		 */ intersectsPlane(plane) {
	        // check if the ray lies on the plane first
	        const distToPoint = plane.distanceToPoint(this.origin);
	        if (distToPoint === 0) {
	            return true;
	        }
	        const denominator = plane.normal.dot(this.direction);
	        if (denominator * distToPoint < 0) {
	            return true;
	        }
	        // ray origin is behind the plane (and is pointing behind it)
	        return false;
	    }
	    /**
		 * Intersects this ray with the given bounding box, returning the intersection
		 * point or `null` if there is no intersection.
		 *
		 * @param {Box3} box - The box to intersect.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The intersection point.
		 */ intersectBox(box, target) {
	        let tmin, tmax, tymin, tymax, tzmin, tzmax;
	        const invdirx = 1 / this.direction.x, invdiry = 1 / this.direction.y, invdirz = 1 / this.direction.z;
	        const origin = this.origin;
	        if (invdirx >= 0) {
	            tmin = (box.min.x - origin.x) * invdirx;
	            tmax = (box.max.x - origin.x) * invdirx;
	        } else {
	            tmin = (box.max.x - origin.x) * invdirx;
	            tmax = (box.min.x - origin.x) * invdirx;
	        }
	        if (invdiry >= 0) {
	            tymin = (box.min.y - origin.y) * invdiry;
	            tymax = (box.max.y - origin.y) * invdiry;
	        } else {
	            tymin = (box.max.y - origin.y) * invdiry;
	            tymax = (box.min.y - origin.y) * invdiry;
	        }
	        if (tmin > tymax || tymin > tmax) return null;
	        if (tymin > tmin || isNaN(tmin)) tmin = tymin;
	        if (tymax < tmax || isNaN(tmax)) tmax = tymax;
	        if (invdirz >= 0) {
	            tzmin = (box.min.z - origin.z) * invdirz;
	            tzmax = (box.max.z - origin.z) * invdirz;
	        } else {
	            tzmin = (box.max.z - origin.z) * invdirz;
	            tzmax = (box.min.z - origin.z) * invdirz;
	        }
	        if (tmin > tzmax || tzmin > tmax) return null;
	        if (tzmin > tmin || tmin !== tmin) tmin = tzmin;
	        if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
	        //return point closest to the ray (positive side)
	        if (tmax < 0) return null;
	        return this.at(tmin >= 0 ? tmin : tmax, target);
	    }
	    /**
		 * Returns `true` if this ray intersects with the given box.
		 *
		 * @param {Box3} box - The box to intersect.
		 * @return {boolean} Whether this ray intersects with the given box or not.
		 */ intersectsBox(box) {
	        return this.intersectBox(box, _vector$a) !== null;
	    }
	    /**
		 * Intersects this ray with the given triangle, returning the intersection
		 * point or `null` if there is no intersection.
		 *
		 * @param {Vector3} a - The first vertex of the triangle.
		 * @param {Vector3} b - The second vertex of the triangle.
		 * @param {Vector3} c - The third vertex of the triangle.
		 * @param {boolean} backfaceCulling - Whether to use backface culling or not.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The intersection point.
		 */ intersectTriangle(a, b, c, backfaceCulling, target) {
	        // Compute the offset origin, edges, and normal.
	        // from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
	        _edge1.subVectors(b, a);
	        _edge2.subVectors(c, a);
	        _normal$1.crossVectors(_edge1, _edge2);
	        // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
	        // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
	        //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
	        //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
	        //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
	        let DdN = this.direction.dot(_normal$1);
	        let sign;
	        if (DdN > 0) {
	            if (backfaceCulling) return null;
	            sign = 1;
	        } else if (DdN < 0) {
	            sign = -1;
	            DdN = -DdN;
	        } else {
	            return null;
	        }
	        _diff.subVectors(this.origin, a);
	        const DdQxE2 = sign * this.direction.dot(_edge2.crossVectors(_diff, _edge2));
	        // b1 < 0, no intersection
	        if (DdQxE2 < 0) {
	            return null;
	        }
	        const DdE1xQ = sign * this.direction.dot(_edge1.cross(_diff));
	        // b2 < 0, no intersection
	        if (DdE1xQ < 0) {
	            return null;
	        }
	        // b1+b2 > 1, no intersection
	        if (DdQxE2 + DdE1xQ > DdN) {
	            return null;
	        }
	        // Line intersects triangle, check if ray does.
	        const QdN = -sign * _diff.dot(_normal$1);
	        // t < 0, no intersection
	        if (QdN < 0) {
	            return null;
	        }
	        // Ray intersects triangle.
	        return this.at(QdN / DdN, target);
	    }
	    /**
		 * Transforms this ray with the given 4x4 transformation matrix.
		 *
		 * @param {Matrix4} matrix4 - The transformation matrix.
		 * @return {Ray} A reference to this ray.
		 */ applyMatrix4(matrix4) {
	        this.origin.applyMatrix4(matrix4);
	        this.direction.transformDirection(matrix4);
	        return this;
	    }
	    /**
		 * Returns `true` if this ray is equal with the given one.
		 *
		 * @param {Ray} ray - The ray to test for equality.
		 * @return {boolean} Whether this ray is equal with the given one.
		 */ equals(ray) {
	        return ray.origin.equals(this.origin) && ray.direction.equals(this.direction);
	    }
	    /**
		 * Returns a new ray with copied values from this instance.
		 *
		 * @return {Ray} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Constructs a new ray.
		 *
		 * @param {Vector3} [origin=(0,0,0)] - The origin of the ray.
		 * @param {Vector3} [direction=(0,0,-1)] - The (normalized) direction of the ray.
		 */ constructor(origin = new Vector3(), direction = new Vector3(0, 0, -1)){
	        /**
			 * The origin of the ray.
			 *
			 * @type {Vector3}
			 */ this.origin = origin;
	        /**
			 * The (normalized) direction of the ray.
			 *
			 * @type {Vector3}
			 */ this.direction = direction;
	    }
	}
	/**
	 * Represents a 4x4 matrix.
	 *
	 * The most common use of a 4x4 matrix in 3D computer graphics is as a transformation matrix.
	 * For an introduction to transformation matrices as used in WebGL, check out [this tutorial]{@link https://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices}
	 *
	 * This allows a 3D vector representing a point in 3D space to undergo
	 * transformations such as translation, rotation, shear, scale, reflection,
	 * orthogonal or perspective projection and so on, by being multiplied by the
	 * matrix. This is known as `applying` the matrix to the vector.
	 *
	 * A Note on Row-Major and Column-Major Ordering:
	 *
	 * The constructor and {@link Matrix3#set} method take arguments in
	 * [row-major]{@link https://en.wikipedia.org/wiki/Row-_and_column-major_order#Column-major_order}
	 * order, while internally they are stored in the {@link Matrix3#elements} array in column-major order.
	 * This means that calling:
	 * ```js
	 * const m = new THREE.Matrix4();
	 * m.set( 11, 12, 13, 14,
	 *        21, 22, 23, 24,
	 *        31, 32, 33, 34,
	 *        41, 42, 43, 44 );
	 * ```
	 * will result in the elements array containing:
	 * ```js
	 * m.elements = [ 11, 21, 31, 41,
	 *                12, 22, 32, 42,
	 *                13, 23, 33, 43,
	 *                14, 24, 34, 44 ];
	 * ```
	 * and internally all calculations are performed using column-major ordering.
	 * However, as the actual ordering makes no difference mathematically and
	 * most people are used to thinking about matrices in row-major order, the
	 * three.js documentation shows matrices in row-major order. Just bear in
	 * mind that if you are reading the source code, you'll have to take the
	 * transpose of any matrices outlined here to make sense of the calculations.
	 */ class Matrix4 {
	    /**
		 * Sets the elements of the matrix.The arguments are supposed to be
		 * in row-major order.
		 *
		 * @param {number} [n11] - 1-1 matrix element.
		 * @param {number} [n12] - 1-2 matrix element.
		 * @param {number} [n13] - 1-3 matrix element.
		 * @param {number} [n14] - 1-4 matrix element.
		 * @param {number} [n21] - 2-1 matrix element.
		 * @param {number} [n22] - 2-2 matrix element.
		 * @param {number} [n23] - 2-3 matrix element.
		 * @param {number} [n24] - 2-4 matrix element.
		 * @param {number} [n31] - 3-1 matrix element.
		 * @param {number} [n32] - 3-2 matrix element.
		 * @param {number} [n33] - 3-3 matrix element.
		 * @param {number} [n34] - 3-4 matrix element.
		 * @param {number} [n41] - 4-1 matrix element.
		 * @param {number} [n42] - 4-2 matrix element.
		 * @param {number} [n43] - 4-3 matrix element.
		 * @param {number} [n44] - 4-4 matrix element.
		 * @return {Matrix4} A reference to this matrix.
		 */ set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
	        const te = this.elements;
	        te[0] = n11;
	        te[4] = n12;
	        te[8] = n13;
	        te[12] = n14;
	        te[1] = n21;
	        te[5] = n22;
	        te[9] = n23;
	        te[13] = n24;
	        te[2] = n31;
	        te[6] = n32;
	        te[10] = n33;
	        te[14] = n34;
	        te[3] = n41;
	        te[7] = n42;
	        te[11] = n43;
	        te[15] = n44;
	        return this;
	    }
	    /**
		 * Sets this matrix to the 4x4 identity matrix.
		 *
		 * @return {Matrix4} A reference to this matrix.
		 */ identity() {
	        this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Returns a matrix with copied values from this instance.
		 *
		 * @return {Matrix4} A clone of this instance.
		 */ clone() {
	        return new Matrix4().fromArray(this.elements);
	    }
	    /**
		 * Copies the values of the given matrix to this instance.
		 *
		 * @param {Matrix4} m - The matrix to copy.
		 * @return {Matrix4} A reference to this matrix.
		 */ 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];
	        te[9] = me[9];
	        te[10] = me[10];
	        te[11] = me[11];
	        te[12] = me[12];
	        te[13] = me[13];
	        te[14] = me[14];
	        te[15] = me[15];
	        return this;
	    }
	    /**
		 * Copies the translation component of the given matrix
		 * into this matrix's translation component.
		 *
		 * @param {Matrix4} m - The matrix to copy the translation component.
		 * @return {Matrix4} A reference to this matrix.
		 */ copyPosition(m) {
	        const te = this.elements, me = m.elements;
	        te[12] = me[12];
	        te[13] = me[13];
	        te[14] = me[14];
	        return this;
	    }
	    /**
		 * Set the upper 3x3 elements of this matrix to the values of given 3x3 matrix.
		 *
		 * @param {Matrix3} m - The 3x3 matrix.
		 * @return {Matrix4} A reference to this matrix.
		 */ setFromMatrix3(m) {
	        const me = m.elements;
	        this.set(me[0], me[3], me[6], 0, me[1], me[4], me[7], 0, me[2], me[5], me[8], 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Extracts the basis of this matrix into the three axis vectors provided.
		 *
		 * @param {Vector3} xAxis - The basis's x axis.
		 * @param {Vector3} yAxis - The basis's y axis.
		 * @param {Vector3} zAxis - The basis's z axis.
		 * @return {Matrix4} A reference to this matrix.
		 */ extractBasis(xAxis, yAxis, zAxis) {
	        xAxis.setFromMatrixColumn(this, 0);
	        yAxis.setFromMatrixColumn(this, 1);
	        zAxis.setFromMatrixColumn(this, 2);
	        return this;
	    }
	    /**
		 * Sets the given basis vectors to this matrix.
		 *
		 * @param {Vector3} xAxis - The basis's x axis.
		 * @param {Vector3} yAxis - The basis's y axis.
		 * @param {Vector3} zAxis - The basis's z axis.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeBasis(xAxis, yAxis, zAxis) {
	        this.set(xAxis.x, yAxis.x, zAxis.x, 0, xAxis.y, yAxis.y, zAxis.y, 0, xAxis.z, yAxis.z, zAxis.z, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Extracts the rotation component of the given matrix
		 * into this matrix's rotation component.
		 *
		 * Note: This method does not support reflection matrices.
		 *
		 * @param {Matrix4} m - The matrix.
		 * @return {Matrix4} A reference to this matrix.
		 */ extractRotation(m) {
	        const te = this.elements;
	        const me = m.elements;
	        const scaleX = 1 / _v1$5.setFromMatrixColumn(m, 0).length();
	        const scaleY = 1 / _v1$5.setFromMatrixColumn(m, 1).length();
	        const scaleZ = 1 / _v1$5.setFromMatrixColumn(m, 2).length();
	        te[0] = me[0] * scaleX;
	        te[1] = me[1] * scaleX;
	        te[2] = me[2] * scaleX;
	        te[3] = 0;
	        te[4] = me[4] * scaleY;
	        te[5] = me[5] * scaleY;
	        te[6] = me[6] * scaleY;
	        te[7] = 0;
	        te[8] = me[8] * scaleZ;
	        te[9] = me[9] * scaleZ;
	        te[10] = me[10] * scaleZ;
	        te[11] = 0;
	        te[12] = 0;
	        te[13] = 0;
	        te[14] = 0;
	        te[15] = 1;
	        return this;
	    }
	    /**
		 * Sets the rotation component (the upper left 3x3 matrix) of this matrix to
		 * the rotation specified by the given Euler angles. The rest of
		 * the matrix is set to the identity. Depending on the {@link Euler#order},
		 * there are six possible outcomes. See [this page]{@link https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix}
		 * for a complete list.
		 *
		 * @param {Euler} euler - The Euler angles.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeRotationFromEuler(euler) {
	        const te = this.elements;
	        const x = euler.x, y = euler.y, z = euler.z;
	        const a = Math.cos(x), b = Math.sin(x);
	        const c = Math.cos(y), d = Math.sin(y);
	        const e = Math.cos(z), f = Math.sin(z);
	        if (euler.order === 'XYZ') {
	            const ae = a * e, af = a * f, be = b * e, bf = b * f;
	            te[0] = c * e;
	            te[4] = -c * f;
	            te[8] = d;
	            te[1] = af + be * d;
	            te[5] = ae - bf * d;
	            te[9] = -b * c;
	            te[2] = bf - ae * d;
	            te[6] = be + af * d;
	            te[10] = a * c;
	        } else if (euler.order === 'YXZ') {
	            const ce = c * e, cf = c * f, de = d * e, df = d * f;
	            te[0] = ce + df * b;
	            te[4] = de * b - cf;
	            te[8] = a * d;
	            te[1] = a * f;
	            te[5] = a * e;
	            te[9] = -b;
	            te[2] = cf * b - de;
	            te[6] = df + ce * b;
	            te[10] = a * c;
	        } else if (euler.order === 'ZXY') {
	            const ce = c * e, cf = c * f, de = d * e, df = d * f;
	            te[0] = ce - df * b;
	            te[4] = -a * f;
	            te[8] = de + cf * b;
	            te[1] = cf + de * b;
	            te[5] = a * e;
	            te[9] = df - ce * b;
	            te[2] = -a * d;
	            te[6] = b;
	            te[10] = a * c;
	        } else if (euler.order === 'ZYX') {
	            const ae = a * e, af = a * f, be = b * e, bf = b * f;
	            te[0] = c * e;
	            te[4] = be * d - af;
	            te[8] = ae * d + bf;
	            te[1] = c * f;
	            te[5] = bf * d + ae;
	            te[9] = af * d - be;
	            te[2] = -d;
	            te[6] = b * c;
	            te[10] = a * c;
	        } else if (euler.order === 'YZX') {
	            const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
	            te[0] = c * e;
	            te[4] = bd - ac * f;
	            te[8] = bc * f + ad;
	            te[1] = f;
	            te[5] = a * e;
	            te[9] = -b * e;
	            te[2] = -d * e;
	            te[6] = ad * f + bc;
	            te[10] = ac - bd * f;
	        } else if (euler.order === 'XZY') {
	            const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
	            te[0] = c * e;
	            te[4] = -f;
	            te[8] = d * e;
	            te[1] = ac * f + bd;
	            te[5] = a * e;
	            te[9] = ad * f - bc;
	            te[2] = bc * f - ad;
	            te[6] = b * e;
	            te[10] = bd * f + ac;
	        }
	        // bottom row
	        te[3] = 0;
	        te[7] = 0;
	        te[11] = 0;
	        // last column
	        te[12] = 0;
	        te[13] = 0;
	        te[14] = 0;
	        te[15] = 1;
	        return this;
	    }
	    /**
		 * Sets the rotation component of this matrix to the rotation specified by
		 * the given Quaternion as outlined [here]{@link https://en.wikipedia.org/wiki/Rotation_matrix#Quaternion}
		 * The rest of the matrix is set to the identity.
		 *
		 * @param {Quaternion} q - The Quaternion.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeRotationFromQuaternion(q) {
	        return this.compose(_zero, q, _one);
	    }
	    /**
		 * Sets the rotation component of the transformation matrix, looking from `eye` towards
		 * `target`, and oriented by the up-direction.
		 *
		 * @param {Vector3} eye - The eye vector.
		 * @param {Vector3} target - The target vector.
		 * @param {Vector3} up - The up vector.
		 * @return {Matrix4} A reference to this matrix.
		 */ lookAt(eye, target, up) {
	        const te = this.elements;
	        _z.subVectors(eye, target);
	        if (_z.lengthSq() === 0) {
	            // eye and target are in the same position
	            _z.z = 1;
	        }
	        _z.normalize();
	        _x.crossVectors(up, _z);
	        if (_x.lengthSq() === 0) {
	            // up and z are parallel
	            if (Math.abs(up.z) === 1) {
	                _z.x += 0.0001;
	            } else {
	                _z.z += 0.0001;
	            }
	            _z.normalize();
	            _x.crossVectors(up, _z);
	        }
	        _x.normalize();
	        _y.crossVectors(_z, _x);
	        te[0] = _x.x;
	        te[4] = _y.x;
	        te[8] = _z.x;
	        te[1] = _x.y;
	        te[5] = _y.y;
	        te[9] = _z.y;
	        te[2] = _x.z;
	        te[6] = _y.z;
	        te[10] = _z.z;
	        return this;
	    }
	    /**
		 * Post-multiplies this matrix by the given 4x4 matrix.
		 *
		 * @param {Matrix4} m - The matrix to multiply with.
		 * @return {Matrix4} A reference to this matrix.
		 */ multiply(m) {
	        return this.multiplyMatrices(this, m);
	    }
	    /**
		 * Pre-multiplies this matrix by the given 4x4 matrix.
		 *
		 * @param {Matrix4} m - The matrix to multiply with.
		 * @return {Matrix4} A reference to this matrix.
		 */ premultiply(m) {
	        return this.multiplyMatrices(m, this);
	    }
	    /**
		 * Multiples the given 4x4 matrices and stores the result
		 * in this matrix.
		 *
		 * @param {Matrix4} a - The first matrix.
		 * @param {Matrix4} b - The second matrix.
		 * @return {Matrix4} A reference to this matrix.
		 */ multiplyMatrices(a, b) {
	        const ae = a.elements;
	        const be = b.elements;
	        const te = this.elements;
	        const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
	        const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
	        const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
	        const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
	        const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
	        const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
	        const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
	        const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
	        te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
	        te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
	        te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
	        te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
	        te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
	        te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
	        te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
	        te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
	        te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
	        te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
	        te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
	        te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
	        te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
	        te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
	        te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
	        te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
	        return this;
	    }
	    /**
		 * Multiplies every component of the matrix by the given scalar.
		 *
		 * @param {number} s - The scalar.
		 * @return {Matrix4} A reference to this matrix.
		 */ multiplyScalar(s) {
	        const te = this.elements;
	        te[0] *= s;
	        te[4] *= s;
	        te[8] *= s;
	        te[12] *= s;
	        te[1] *= s;
	        te[5] *= s;
	        te[9] *= s;
	        te[13] *= s;
	        te[2] *= s;
	        te[6] *= s;
	        te[10] *= s;
	        te[14] *= s;
	        te[3] *= s;
	        te[7] *= s;
	        te[11] *= s;
	        te[15] *= s;
	        return this;
	    }
	    /**
		 * Computes and returns the determinant of this matrix.
		 *
		 * Based on the method outlined [here]{@link http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.html}.
		 *
		 * @return {number} The determinant.
		 */ determinant() {
	        const te = this.elements;
	        const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12];
	        const n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13];
	        const n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14];
	        const n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15];
	        //TODO: make this more efficient
	        return n41 * (+n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34) + n42 * (+n11 * n23 * n34 - n11 * n24 * n33 + n14 * n21 * n33 - n13 * n21 * n34 + n13 * n24 * n31 - n14 * n23 * n31) + n43 * (+n11 * n24 * n32 - n11 * n22 * n34 - n14 * n21 * n32 + n12 * n21 * n34 + n14 * n22 * n31 - n12 * n24 * n31) + n44 * (-n13 * n22 * n31 - n11 * n23 * n32 + n11 * n22 * n33 + n13 * n21 * n32 - n12 * n21 * n33 + n12 * n23 * n31);
	    }
	    /**
		 * Transposes this matrix in place.
		 *
		 * @return {Matrix4} A reference to this matrix.
		 */ transpose() {
	        const te = this.elements;
	        let tmp;
	        tmp = te[1];
	        te[1] = te[4];
	        te[4] = tmp;
	        tmp = te[2];
	        te[2] = te[8];
	        te[8] = tmp;
	        tmp = te[6];
	        te[6] = te[9];
	        te[9] = tmp;
	        tmp = te[3];
	        te[3] = te[12];
	        te[12] = tmp;
	        tmp = te[7];
	        te[7] = te[13];
	        te[13] = tmp;
	        tmp = te[11];
	        te[11] = te[14];
	        te[14] = tmp;
	        return this;
	    }
	    /**
		 * Sets the position component for this matrix from the given vector,
		 * without affecting the rest of the matrix.
		 *
		 * @param {number|Vector3} x - The x component of the vector or alternatively the vector object.
		 * @param {number} y - The y component of the vector.
		 * @param {number} z - The z component of the vector.
		 * @return {Matrix4} A reference to this matrix.
		 */ setPosition(x, y, z) {
	        const te = this.elements;
	        if (x.isVector3) {
	            te[12] = x.x;
	            te[13] = x.y;
	            te[14] = x.z;
	        } else {
	            te[12] = x;
	            te[13] = y;
	            te[14] = z;
	        }
	        return this;
	    }
	    /**
		 * Inverts this matrix, using the [analytic method]{@link https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution}.
		 * You can not invert with a determinant of zero. If you attempt this, the method produces
		 * a zero matrix instead.
		 *
		 * @return {Matrix4} A reference to this matrix.
		 */ invert() {
	        // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
	        const te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n41 = te[3], n12 = te[4], n22 = te[5], n32 = te[6], n42 = te[7], n13 = te[8], n23 = te[9], n33 = te[10], n43 = te[11], n14 = te[12], n24 = te[13], n34 = te[14], n44 = te[15], t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44, t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44, t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44, t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
	        const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
	        if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	        const detInv = 1 / det;
	        te[0] = t11 * detInv;
	        te[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv;
	        te[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv;
	        te[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv;
	        te[4] = t12 * detInv;
	        te[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv;
	        te[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv;
	        te[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv;
	        te[8] = t13 * detInv;
	        te[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv;
	        te[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv;
	        te[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv;
	        te[12] = t14 * detInv;
	        te[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv;
	        te[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv;
	        te[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv;
	        return this;
	    }
	    /**
		 * Multiplies the columns of this matrix by the given vector.
		 *
		 * @param {Vector3} v - The scale vector.
		 * @return {Matrix4} A reference to this matrix.
		 */ scale(v) {
	        const te = this.elements;
	        const x = v.x, y = v.y, z = v.z;
	        te[0] *= x;
	        te[4] *= y;
	        te[8] *= z;
	        te[1] *= x;
	        te[5] *= y;
	        te[9] *= z;
	        te[2] *= x;
	        te[6] *= y;
	        te[10] *= z;
	        te[3] *= x;
	        te[7] *= y;
	        te[11] *= z;
	        return this;
	    }
	    /**
		 * Gets the maximum scale value of the three axes.
		 *
		 * @return {number} The maximum scale.
		 */ 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));
	    }
	    /**
		 * Sets this matrix as a translation transform from the given vector.
		 *
		 * @param {number|Vector3} x - The amount to translate in the X axis or alternatively a translation vector.
		 * @param {number} y - The amount to translate in the Y axis.
		 * @param {number} z - The amount to translate in the z axis.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeTranslation(x, y, z) {
	        if (x.isVector3) {
	            this.set(1, 0, 0, x.x, 0, 1, 0, x.y, 0, 0, 1, x.z, 0, 0, 0, 1);
	        } else {
	            this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1);
	        }
	        return this;
	    }
	    /**
		 * Sets this matrix as a rotational transformation around the X axis by
		 * the given angle.
		 *
		 * @param {number} theta - The rotation in radians.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeRotationX(theta) {
	        const c = Math.cos(theta), s = Math.sin(theta);
	        this.set(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix as a rotational transformation around the Y axis by
		 * the given angle.
		 *
		 * @param {number} theta - The rotation in radians.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeRotationY(theta) {
	        const c = Math.cos(theta), s = Math.sin(theta);
	        this.set(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix as a rotational transformation around the Z axis by
		 * the given angle.
		 *
		 * @param {number} theta - The rotation in radians.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeRotationZ(theta) {
	        const c = Math.cos(theta), s = Math.sin(theta);
	        this.set(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix as a rotational transformation around the given axis by
		 * the given angle.
		 *
		 * This is a somewhat controversial but mathematically sound alternative to
		 * rotating via Quaternions. See the discussion [here]{@link https://www.gamedev.net/articles/programming/math-and-physics/do-we-really-need-quaternions-r1199}.
		 *
		 * @param {Vector3} axis - The normalized rotation axis.
		 * @param {number} angle - The rotation in radians.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeRotationAxis(axis, angle) {
	        // Based on http://www.gamedev.net/reference/articles/article1199.asp
	        const c = Math.cos(angle);
	        const s = Math.sin(angle);
	        const t = 1 - c;
	        const x = axis.x, y = axis.y, z = axis.z;
	        const tx = t * x, ty = t * y;
	        this.set(tx * x + c, tx * y - s * z, tx * z + s * y, 0, tx * y + s * z, ty * y + c, ty * z - s * x, 0, tx * z - s * y, ty * z + s * x, t * z * z + c, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix as a scale transformation.
		 *
		 * @param {number} x - The amount to scale in the X axis.
		 * @param {number} y - The amount to scale in the Y axis.
		 * @param {number} z - The amount to scale in the Z axis.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeScale(x, y, z) {
	        this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix as a shear transformation.
		 *
		 * @param {number} xy - The amount to shear X by Y.
		 * @param {number} xz - The amount to shear X by Z.
		 * @param {number} yx - The amount to shear Y by X.
		 * @param {number} yz - The amount to shear Y by Z.
		 * @param {number} zx - The amount to shear Z by X.
		 * @param {number} zy - The amount to shear Z by Y.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeShear(xy, xz, yx, yz, zx, zy) {
	        this.set(1, yx, zx, 0, xy, 1, zy, 0, xz, yz, 1, 0, 0, 0, 0, 1);
	        return this;
	    }
	    /**
		 * Sets this matrix to the transformation composed of the given position,
		 * rotation (Quaternion) and scale.
		 *
		 * @param {Vector3} position - The position vector.
		 * @param {Quaternion} quaternion - The rotation as a Quaternion.
		 * @param {Vector3} scale - The scale vector.
		 * @return {Matrix4} A reference to this matrix.
		 */ compose(position, quaternion, scale) {
	        const te = this.elements;
	        const x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
	        const x2 = x + x, y2 = y + y, z2 = z + z;
	        const xx = x * x2, xy = x * y2, xz = x * z2;
	        const yy = y * y2, yz = y * z2, zz = z * z2;
	        const wx = w * x2, wy = w * y2, wz = w * z2;
	        const sx = scale.x, sy = scale.y, sz = scale.z;
	        te[0] = (1 - (yy + zz)) * sx;
	        te[1] = (xy + wz) * sx;
	        te[2] = (xz - wy) * sx;
	        te[3] = 0;
	        te[4] = (xy - wz) * sy;
	        te[5] = (1 - (xx + zz)) * sy;
	        te[6] = (yz + wx) * sy;
	        te[7] = 0;
	        te[8] = (xz + wy) * sz;
	        te[9] = (yz - wx) * sz;
	        te[10] = (1 - (xx + yy)) * sz;
	        te[11] = 0;
	        te[12] = position.x;
	        te[13] = position.y;
	        te[14] = position.z;
	        te[15] = 1;
	        return this;
	    }
	    /**
		 * Decomposes this matrix into its position, rotation and scale components
		 * and provides the result in the given objects.
		 *
		 * Note: Not all matrices are decomposable in this way. For example, if an
		 * object has a non-uniformly scaled parent, then the object's world matrix
		 * may not be decomposable, and this method may not be appropriate.
		 *
		 * @param {Vector3} position - The position vector.
		 * @param {Quaternion} quaternion - The rotation as a Quaternion.
		 * @param {Vector3} scale - The scale vector.
		 * @return {Matrix4} A reference to this matrix.
		 */ decompose(position, quaternion, scale) {
	        const te = this.elements;
	        let sx = _v1$5.set(te[0], te[1], te[2]).length();
	        const sy = _v1$5.set(te[4], te[5], te[6]).length();
	        const sz = _v1$5.set(te[8], te[9], te[10]).length();
	        // if determine is negative, we need to invert one scale
	        const det = this.determinant();
	        if (det < 0) sx = -sx;
	        position.x = te[12];
	        position.y = te[13];
	        position.z = te[14];
	        // scale the rotation part
	        _m1$2.copy(this);
	        const invSX = 1 / sx;
	        const invSY = 1 / sy;
	        const invSZ = 1 / sz;
	        _m1$2.elements[0] *= invSX;
	        _m1$2.elements[1] *= invSX;
	        _m1$2.elements[2] *= invSX;
	        _m1$2.elements[4] *= invSY;
	        _m1$2.elements[5] *= invSY;
	        _m1$2.elements[6] *= invSY;
	        _m1$2.elements[8] *= invSZ;
	        _m1$2.elements[9] *= invSZ;
	        _m1$2.elements[10] *= invSZ;
	        quaternion.setFromRotationMatrix(_m1$2);
	        scale.x = sx;
	        scale.y = sy;
	        scale.z = sz;
	        return this;
	    }
	    /**
		 * Creates a perspective projection matrix. This is used internally by
		 * {@link PerspectiveCamera#updateProjectionMatrix}.

		 * @param {number} left - Left boundary of the viewing frustum at the near plane.
		 * @param {number} right - Right boundary of the viewing frustum at the near plane.
		 * @param {number} top - Top boundary of the viewing frustum at the near plane.
		 * @param {number} bottom - Bottom boundary of the viewing frustum at the near plane.
		 * @param {number} near - The distance from the camera to the near plane.
		 * @param {number} far - The distance from the camera to the far plane.
		 * @param {(WebGLCoordinateSystem|WebGPUCoordinateSystem)} [coordinateSystem=WebGLCoordinateSystem] - The coordinate system.
		 * @return {Matrix4} A reference to this matrix.
		 */ makePerspective(left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) {
	        const te = this.elements;
	        const x = 2 * near / (right - left);
	        const y = 2 * near / (top - bottom);
	        const a = (right + left) / (right - left);
	        const b = (top + bottom) / (top - bottom);
	        let c, d;
	        if (coordinateSystem === WebGLCoordinateSystem) {
	            c = -(far + near) / (far - near);
	            d = -2 * far * near / (far - near);
	        } else if (coordinateSystem === WebGPUCoordinateSystem) {
	            c = -far / (far - near);
	            d = -far * near / (far - near);
	        } else {
	            throw new Error('THREE.Matrix4.makePerspective(): Invalid coordinate system: ' + coordinateSystem);
	        }
	        te[0] = x;
	        te[4] = 0;
	        te[8] = a;
	        te[12] = 0;
	        te[1] = 0;
	        te[5] = y;
	        te[9] = b;
	        te[13] = 0;
	        te[2] = 0;
	        te[6] = 0;
	        te[10] = c;
	        te[14] = d;
	        te[3] = 0;
	        te[7] = 0;
	        te[11] = -1;
	        te[15] = 0;
	        return this;
	    }
	    /**
		 * Creates a orthographic projection matrix. This is used internally by
		 * {@link OrthographicCamera#updateProjectionMatrix}.

		 * @param {number} left - Left boundary of the viewing frustum at the near plane.
		 * @param {number} right - Right boundary of the viewing frustum at the near plane.
		 * @param {number} top - Top boundary of the viewing frustum at the near plane.
		 * @param {number} bottom - Bottom boundary of the viewing frustum at the near plane.
		 * @param {number} near - The distance from the camera to the near plane.
		 * @param {number} far - The distance from the camera to the far plane.
		 * @param {(WebGLCoordinateSystem|WebGPUCoordinateSystem)} [coordinateSystem=WebGLCoordinateSystem] - The coordinate system.
		 * @return {Matrix4} A reference to this matrix.
		 */ makeOrthographic(left, right, top, bottom, near, far, coordinateSystem = WebGLCoordinateSystem) {
	        const te = this.elements;
	        const w = 1.0 / (right - left);
	        const h = 1.0 / (top - bottom);
	        const p = 1.0 / (far - near);
	        const x = (right + left) * w;
	        const y = (top + bottom) * h;
	        let z, zInv;
	        if (coordinateSystem === WebGLCoordinateSystem) {
	            z = (far + near) * p;
	            zInv = -2 * p;
	        } else if (coordinateSystem === WebGPUCoordinateSystem) {
	            z = near * p;
	            zInv = -1 * p;
	        } else {
	            throw new Error('THREE.Matrix4.makeOrthographic(): Invalid coordinate system: ' + coordinateSystem);
	        }
	        te[0] = 2 * w;
	        te[4] = 0;
	        te[8] = 0;
	        te[12] = -x;
	        te[1] = 0;
	        te[5] = 2 * h;
	        te[9] = 0;
	        te[13] = -y;
	        te[2] = 0;
	        te[6] = 0;
	        te[10] = zInv;
	        te[14] = -z;
	        te[3] = 0;
	        te[7] = 0;
	        te[11] = 0;
	        te[15] = 1;
	        return this;
	    }
	    /**
		 * Returns `true` if this matrix is equal with the given one.
		 *
		 * @param {Matrix4} matrix - The matrix to test for equality.
		 * @return {boolean} Whether this matrix is equal with the given one.
		 */ equals(matrix) {
	        const te = this.elements;
	        const me = matrix.elements;
	        for(let i = 0; i < 16; i++){
	            if (te[i] !== me[i]) return false;
	        }
	        return true;
	    }
	    /**
		 * Sets the elements of the matrix from the given array.
		 *
		 * @param {Array<number>} array - The matrix elements in column-major order.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Matrix4} A reference to this matrix.
		 */ fromArray(array, offset = 0) {
	        for(let i = 0; i < 16; i++){
	            this.elements[i] = array[i + offset];
	        }
	        return this;
	    }
	    /**
		 * Writes the elements of this matrix to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the matrix elements in column-major order.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The matrix elements in column-major order.
		 */ 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];
	        array[offset + 9] = te[9];
	        array[offset + 10] = te[10];
	        array[offset + 11] = te[11];
	        array[offset + 12] = te[12];
	        array[offset + 13] = te[13];
	        array[offset + 14] = te[14];
	        array[offset + 15] = te[15];
	        return array;
	    }
	    /**
		 * Constructs a new 4x4 matrix. The arguments are supposed to be
		 * in row-major order. If no arguments are provided, the constructor
		 * initializes the matrix as an identity matrix.
		 *
		 * @param {number} [n11] - 1-1 matrix element.
		 * @param {number} [n12] - 1-2 matrix element.
		 * @param {number} [n13] - 1-3 matrix element.
		 * @param {number} [n14] - 1-4 matrix element.
		 * @param {number} [n21] - 2-1 matrix element.
		 * @param {number} [n22] - 2-2 matrix element.
		 * @param {number} [n23] - 2-3 matrix element.
		 * @param {number} [n24] - 2-4 matrix element.
		 * @param {number} [n31] - 3-1 matrix element.
		 * @param {number} [n32] - 3-2 matrix element.
		 * @param {number} [n33] - 3-3 matrix element.
		 * @param {number} [n34] - 3-4 matrix element.
		 * @param {number} [n41] - 4-1 matrix element.
		 * @param {number} [n42] - 4-2 matrix element.
		 * @param {number} [n43] - 4-3 matrix element.
		 * @param {number} [n44] - 4-4 matrix element.
		 */ constructor(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ Matrix4.prototype.isMatrix4 = true;
	        /**
			 * A column-major list of matrix values.
			 *
			 * @type {Array<number>}
			 */ this.elements = [
	            1,
	            0,
	            0,
	            0,
	            0,
	            1,
	            0,
	            0,
	            0,
	            0,
	            1,
	            0,
	            0,
	            0,
	            0,
	            1
	        ];
	        if (n11 !== undefined) {
	            this.set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44);
	        }
	    }
	}
	const _v1$5 = /*@__PURE__*/ new Vector3();
	const _m1$2 = /*@__PURE__*/ new Matrix4();
	const _zero = /*@__PURE__*/ new Vector3(0, 0, 0);
	const _one = /*@__PURE__*/ new Vector3(1, 1, 1);
	const _x = /*@__PURE__*/ new Vector3();
	const _y = /*@__PURE__*/ new Vector3();
	const _z = /*@__PURE__*/ new Vector3();
	const _matrix$2 = /*@__PURE__*/ new Matrix4();
	const _quaternion$3 = /*@__PURE__*/ new Quaternion();
	/**
	 * A class representing Euler angles.
	 *
	 * Euler angles describe a rotational transformation by rotating an object on
	 * its various axes in specified amounts per axis, and a specified axis
	 * order.
	 *
	 * Iterating through an instance will yield its components (x, y, z,
	 * order) in the corresponding order.
	 *
	 * ```js
	 * const a = new THREE.Euler( 0, 1, 1.57, 'XYZ' );
	 * const b = new THREE.Vector3( 1, 0, 1 );
	 * b.applyEuler(a);
	 * ```
	 */ class Euler {
	    /**
		 * The angle of the x axis in radians.
		 *
		 * @type {number}
		 * @default 0
		 */ get x() {
	        return this._x;
	    }
	    set x(value) {
	        this._x = value;
	        this._onChangeCallback();
	    }
	    /**
		 * The angle of the y axis in radians.
		 *
		 * @type {number}
		 * @default 0
		 */ get y() {
	        return this._y;
	    }
	    set y(value) {
	        this._y = value;
	        this._onChangeCallback();
	    }
	    /**
		 * The angle of the z axis in radians.
		 *
		 * @type {number}
		 * @default 0
		 */ get z() {
	        return this._z;
	    }
	    set z(value) {
	        this._z = value;
	        this._onChangeCallback();
	    }
	    /**
		 * A string representing the order that the rotations are applied.
		 *
		 * @type {string}
		 * @default 'XYZ'
		 */ get order() {
	        return this._order;
	    }
	    set order(value) {
	        this._order = value;
	        this._onChangeCallback();
	    }
	    /**
		 * Sets the Euler components.
		 *
		 * @param {number} x - The angle of the x axis in radians.
		 * @param {number} y - The angle of the y axis in radians.
		 * @param {number} z - The angle of the z axis in radians.
		 * @param {string} [order] - A string representing the order that the rotations are applied.
		 * @return {Euler} A reference to this Euler instance.
		 */ set(x, y, z, order = this._order) {
	        this._x = x;
	        this._y = y;
	        this._z = z;
	        this._order = order;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Returns a new Euler instance with copied values from this instance.
		 *
		 * @return {Euler} A clone of this instance.
		 */ clone() {
	        return new this.constructor(this._x, this._y, this._z, this._order);
	    }
	    /**
		 * Copies the values of the given Euler instance to this instance.
		 *
		 * @param {Euler} euler - The Euler instance to copy.
		 * @return {Euler} A reference to this Euler instance.
		 */ copy(euler) {
	        this._x = euler._x;
	        this._y = euler._y;
	        this._z = euler._z;
	        this._order = euler._order;
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Sets the angles of this Euler instance from a pure rotation matrix.
		 *
		 * @param {Matrix4} m - A 4x4 matrix of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
		 * @param {string} [order] - A string representing the order that the rotations are applied.
		 * @param {boolean} [update=true] - Whether the internal `onChange` callback should be executed or not.
		 * @return {Euler} A reference to this Euler instance.
		 */ setFromRotationMatrix(m, order = this._order, update = true) {
	        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];
	        switch(order){
	            case 'XYZ':
	                this._y = Math.asin(clamp$1(m13, -1, 1));
	                if (Math.abs(m13) < 0.9999999) {
	                    this._x = Math.atan2(-m23, m33);
	                    this._z = Math.atan2(-m12, m11);
	                } else {
	                    this._x = Math.atan2(m32, m22);
	                    this._z = 0;
	                }
	                break;
	            case 'YXZ':
	                this._x = Math.asin(-clamp$1(m23, -1, 1));
	                if (Math.abs(m23) < 0.9999999) {
	                    this._y = Math.atan2(m13, m33);
	                    this._z = Math.atan2(m21, m22);
	                } else {
	                    this._y = Math.atan2(-m31, m11);
	                    this._z = 0;
	                }
	                break;
	            case 'ZXY':
	                this._x = Math.asin(clamp$1(m32, -1, 1));
	                if (Math.abs(m32) < 0.9999999) {
	                    this._y = Math.atan2(-m31, m33);
	                    this._z = Math.atan2(-m12, m22);
	                } else {
	                    this._y = 0;
	                    this._z = Math.atan2(m21, m11);
	                }
	                break;
	            case 'ZYX':
	                this._y = Math.asin(-clamp$1(m31, -1, 1));
	                if (Math.abs(m31) < 0.9999999) {
	                    this._x = Math.atan2(m32, m33);
	                    this._z = Math.atan2(m21, m11);
	                } else {
	                    this._x = 0;
	                    this._z = Math.atan2(-m12, m22);
	                }
	                break;
	            case 'YZX':
	                this._z = Math.asin(clamp$1(m21, -1, 1));
	                if (Math.abs(m21) < 0.9999999) {
	                    this._x = Math.atan2(-m23, m22);
	                    this._y = Math.atan2(-m31, m11);
	                } else {
	                    this._x = 0;
	                    this._y = Math.atan2(m13, m33);
	                }
	                break;
	            case 'XZY':
	                this._z = Math.asin(-clamp$1(m12, -1, 1));
	                if (Math.abs(m12) < 0.9999999) {
	                    this._x = Math.atan2(m32, m22);
	                    this._y = Math.atan2(m13, m11);
	                } else {
	                    this._x = Math.atan2(-m23, m33);
	                    this._y = 0;
	                }
	                break;
	            default:
	                console.warn('THREE.Euler: .setFromRotationMatrix() encountered an unknown order: ' + order);
	        }
	        this._order = order;
	        if (update === true) this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Sets the angles of this Euler instance from a normalized quaternion.
		 *
		 * @param {Quaternion} q - A normalized Quaternion.
		 * @param {string} [order] - A string representing the order that the rotations are applied.
		 * @param {boolean} [update=true] - Whether the internal `onChange` callback should be executed or not.
		 * @return {Euler} A reference to this Euler instance.
		 */ setFromQuaternion(q, order, update) {
	        _matrix$2.makeRotationFromQuaternion(q);
	        return this.setFromRotationMatrix(_matrix$2, order, update);
	    }
	    /**
		 * Sets the angles of this Euler instance from the given vector.
		 *
		 * @param {Vector3} v - The vector.
		 * @param {string} [order] - A string representing the order that the rotations are applied.
		 * @return {Euler} A reference to this Euler instance.
		 */ setFromVector3(v, order = this._order) {
	        return this.set(v.x, v.y, v.z, order);
	    }
	    /**
		 * Resets the euler angle with a new order by creating a quaternion from this
		 * euler angle and then setting this euler angle with the quaternion and the
		 * new order.
		 *
		 * Warning: This discards revolution information.
		 *
		 * @param {string} [newOrder] - A string representing the new order that the rotations are applied.
		 * @return {Euler} A reference to this Euler instance.
		 */ reorder(newOrder) {
	        _quaternion$3.setFromEuler(this);
	        return this.setFromQuaternion(_quaternion$3, newOrder);
	    }
	    /**
		 * Returns `true` if this Euler instance is equal with the given one.
		 *
		 * @param {Euler} euler - The Euler instance to test for equality.
		 * @return {boolean} Whether this Euler instance is equal with the given one.
		 */ equals(euler) {
	        return euler._x === this._x && euler._y === this._y && euler._z === this._z && euler._order === this._order;
	    }
	    /**
		 * Sets this Euler instance's components to values from the given array. The first three
		 * entries of the array are assign to the x,y and z components. An optional fourth entry
		 * defines the Euler order.
		 *
		 * @param {Array<number,number,number,?string>} array - An array holding the Euler component values.
		 * @return {Euler} A reference to this Euler instance.
		 */ fromArray(array) {
	        this._x = array[0];
	        this._y = array[1];
	        this._z = array[2];
	        if (array[3] !== undefined) this._order = array[3];
	        this._onChangeCallback();
	        return this;
	    }
	    /**
		 * Writes the components of this Euler instance to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number,number,number,string>} [array=[]] - The target array holding the Euler components.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number,number,number,string>} The Euler components.
		 */ toArray(array = [], offset = 0) {
	        array[offset] = this._x;
	        array[offset + 1] = this._y;
	        array[offset + 2] = this._z;
	        array[offset + 3] = this._order;
	        return array;
	    }
	    _onChange(callback) {
	        this._onChangeCallback = callback;
	        return this;
	    }
	    _onChangeCallback() {}
	    *[Symbol.iterator]() {
	        yield this._x;
	        yield this._y;
	        yield this._z;
	        yield this._order;
	    }
	    /**
		 * Constructs a new euler instance.
		 *
		 * @param {number} [x=0] - The angle of the x axis in radians.
		 * @param {number} [y=0] - The angle of the y axis in radians.
		 * @param {number} [z=0] - The angle of the z axis in radians.
		 * @param {string} [order=Euler.DEFAULT_ORDER] - A string representing the order that the rotations are applied.
		 */ constructor(x = 0, y = 0, z = 0, order = Euler.DEFAULT_ORDER){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isEuler = true;
	        this._x = x;
	        this._y = y;
	        this._z = z;
	        this._order = order;
	    }
	}
	/**
	 * The default Euler angle order.
	 *
	 * @static
	 * @type {string}
	 * @default 'XYZ'
	 */ Euler.DEFAULT_ORDER = 'XYZ';
	class Layers {
	    set(channel) {
	        this.mask = (1 << channel | 0) >>> 0;
	    }
	    enable(channel) {
	        this.mask |= 1 << channel | 0;
	    }
	    enableAll() {
	        this.mask = 0xffffffff | 0;
	    }
	    toggle(channel) {
	        this.mask ^= 1 << channel | 0;
	    }
	    disable(channel) {
	        this.mask &= ~(1 << channel | 0);
	    }
	    disableAll() {
	        this.mask = 0;
	    }
	    test(layers) {
	        return (this.mask & layers.mask) !== 0;
	    }
	    isEnabled(channel) {
	        return (this.mask & (1 << channel | 0)) !== 0;
	    }
	    constructor(){
	        this.mask = 1 | 0;
	    }
	}
	let _object3DId = 0;
	const _v1$4 = /*@__PURE__*/ new Vector3();
	const _q1 = /*@__PURE__*/ new Quaternion();
	const _m1$1$1 = /*@__PURE__*/ new Matrix4();
	const _target = /*@__PURE__*/ new Vector3();
	const _position$3 = /*@__PURE__*/ new Vector3();
	const _scale$2 = /*@__PURE__*/ new Vector3();
	const _quaternion$2 = /*@__PURE__*/ new Quaternion();
	const _xAxis = /*@__PURE__*/ new Vector3(1, 0, 0);
	const _yAxis = /*@__PURE__*/ new Vector3(0, 1, 0);
	const _zAxis = /*@__PURE__*/ new Vector3(0, 0, 1);
	/**
	 * Fires when the object has been added to its parent object.
	 *
	 * @event Object3D#added
	 * @type {Object}
	 */ const _addedEvent = {
	    type: 'added'
	};
	/**
	 * Fires when the object has been removed from its parent object.
	 *
	 * @event Object3D#removed
	 * @type {Object}
	 */ const _removedEvent = {
	    type: 'removed'
	};
	/**
	 * Fires when a new child object has been added.
	 *
	 * @event Object3D#childadded
	 * @type {Object}
	 */ const _childaddedEvent = {
	    type: 'childadded',
	    child: null
	};
	/**
	 * Fires when a new child object has been added.
	 *
	 * @event Object3D#childremoved
	 * @type {Object}
	 */ const _childremovedEvent = {
	    type: 'childremoved',
	    child: null
	};
	/**
	 * This is the base class for most objects in three.js and provides a set of
	 * properties and methods for manipulating objects in 3D space.
	 *
	 * @augments EventDispatcher
	 */ class Object3D extends EventDispatcher {
	    /**
		 * A callback that is executed immediately before a 3D object is rendered to a shadow map.
		 *
		 * @param {Renderer|WebGLRenderer} renderer - The renderer.
		 * @param {Object3D} object - The 3D object.
		 * @param {Camera} camera - The camera that is used to render the scene.
		 * @param {Camera} shadowCamera - The shadow camera.
		 * @param {BufferGeometry} geometry - The 3D object's geometry.
		 * @param {Material} depthMaterial - The depth material.
		 * @param {Object} group - The geometry group data.
		 */ onBeforeShadow() {}
	    /**
		 * A callback that is executed immediately after a 3D object is rendered to a shadow map.
		 *
		 * @param {Renderer|WebGLRenderer} renderer - The renderer.
		 * @param {Object3D} object - The 3D object.
		 * @param {Camera} camera - The camera that is used to render the scene.
		 * @param {Camera} shadowCamera - The shadow camera.
		 * @param {BufferGeometry} geometry - The 3D object's geometry.
		 * @param {Material} depthMaterial - The depth material.
		 * @param {Object} group - The geometry group data.
		 */ onAfterShadow() {}
	    /**
		 * A callback that is executed immediately before a 3D object is rendered.
		 *
		 * @param {Renderer|WebGLRenderer} renderer - The renderer.
		 * @param {Object3D} object - The 3D object.
		 * @param {Camera} camera - The camera that is used to render the scene.
		 * @param {BufferGeometry} geometry - The 3D object's geometry.
		 * @param {Material} material - The 3D object's material.
		 * @param {Object} group - The geometry group data.
		 */ onBeforeRender() {}
	    /**
		 * A callback that is executed immediately after a 3D object is rendered.
		 *
		 * @param {Renderer|WebGLRenderer} renderer - The renderer.
		 * @param {Object3D} object - The 3D object.
		 * @param {Camera} camera - The camera that is used to render the scene.
		 * @param {BufferGeometry} geometry - The 3D object's geometry.
		 * @param {Material} material - The 3D object's material.
		 * @param {Object} group - The geometry group data.
		 */ onAfterRender() {}
	    /**
		 * Applies the given transformation matrix to the object and updates the object's position,
		 * rotation and scale.
		 *
		 * @param {Matrix4} matrix - The transformation matrix.
		 */ applyMatrix4(matrix) {
	        if (this.matrixAutoUpdate) this.updateMatrix();
	        this.matrix.premultiply(matrix);
	        this.matrix.decompose(this.position, this.quaternion, this.scale);
	    }
	    /**
		 * Applies a rotation represented by given the quaternion to the 3D object.
		 *
		 * @param {Quaternion} q - The quaternion.
		 * @return {Object3D} A reference to this instance.
		 */ applyQuaternion(q) {
	        this.quaternion.premultiply(q);
	        return this;
	    }
	    /**
		 * Sets the given rotation represented as an axis/angle couple to the 3D object.
		 *
		 * @param {Vector3} axis - The (normalized) axis vector.
		 * @param {number} angle - The angle in radians.
		 */ setRotationFromAxisAngle(axis, angle) {
	        // assumes axis is normalized
	        this.quaternion.setFromAxisAngle(axis, angle);
	    }
	    /**
		 * Sets the given rotation represented as Euler angles to the 3D object.
		 *
		 * @param {Euler} euler - The Euler angles.
		 */ setRotationFromEuler(euler) {
	        this.quaternion.setFromEuler(euler, true);
	    }
	    /**
		 * Sets the given rotation represented as rotation matrix to the 3D object.
		 *
		 * @param {Matrix4} m - Although a 4x4 matrix is expected, the upper 3x3 portion must be
		 * a pure rotation matrix (i.e, unscaled).
		 */ setRotationFromMatrix(m) {
	        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
	        this.quaternion.setFromRotationMatrix(m);
	    }
	    /**
		 * Sets the given rotation represented as a Quaternion to the 3D object.
		 *
		 * @param {Quaternion} q - The Quaternion
		 */ setRotationFromQuaternion(q) {
	        // assumes q is normalized
	        this.quaternion.copy(q);
	    }
	    /**
		 * Rotates the 3D object along an axis in local space.
		 *
		 * @param {Vector3} axis - The (normalized) axis vector.
		 * @param {number} angle - The angle in radians.
		 * @return {Object3D} A reference to this instance.
		 */ rotateOnAxis(axis, angle) {
	        // rotate object on axis in object space
	        // axis is assumed to be normalized
	        _q1.setFromAxisAngle(axis, angle);
	        this.quaternion.multiply(_q1);
	        return this;
	    }
	    /**
		 * Rotates the 3D object along an axis in world space.
		 *
		 * @param {Vector3} axis - The (normalized) axis vector.
		 * @param {number} angle - The angle in radians.
		 * @return {Object3D} A reference to this instance.
		 */ rotateOnWorldAxis(axis, angle) {
	        // rotate object on axis in world space
	        // axis is assumed to be normalized
	        // method assumes no rotated parent
	        _q1.setFromAxisAngle(axis, angle);
	        this.quaternion.premultiply(_q1);
	        return this;
	    }
	    /**
		 * Rotates the 3D object around its X axis in local space.
		 *
		 * @param {number} angle - The angle in radians.
		 * @return {Object3D} A reference to this instance.
		 */ rotateX(angle) {
	        return this.rotateOnAxis(_xAxis, angle);
	    }
	    /**
		 * Rotates the 3D object around its Y axis in local space.
		 *
		 * @param {number} angle - The angle in radians.
		 * @return {Object3D} A reference to this instance.
		 */ rotateY(angle) {
	        return this.rotateOnAxis(_yAxis, angle);
	    }
	    /**
		 * Rotates the 3D object around its Z axis in local space.
		 *
		 * @param {number} angle - The angle in radians.
		 * @return {Object3D} A reference to this instance.
		 */ rotateZ(angle) {
	        return this.rotateOnAxis(_zAxis, angle);
	    }
	    /**
		 * Translate the 3D object by a distance along the given axis in local space.
		 *
		 * @param {Vector3} axis - The (normalized) axis vector.
		 * @param {number} distance - The distance in world units.
		 * @return {Object3D} A reference to this instance.
		 */ translateOnAxis(axis, distance) {
	        // translate object by distance along axis in object space
	        // axis is assumed to be normalized
	        _v1$4.copy(axis).applyQuaternion(this.quaternion);
	        this.position.add(_v1$4.multiplyScalar(distance));
	        return this;
	    }
	    /**
		 * Translate the 3D object by a distance along its X-axis in local space.
		 *
		 * @param {number} distance - The distance in world units.
		 * @return {Object3D} A reference to this instance.
		 */ translateX(distance) {
	        return this.translateOnAxis(_xAxis, distance);
	    }
	    /**
		 * Translate the 3D object by a distance along its Y-axis in local space.
		 *
		 * @param {number} distance - The distance in world units.
		 * @return {Object3D} A reference to this instance.
		 */ translateY(distance) {
	        return this.translateOnAxis(_yAxis, distance);
	    }
	    /**
		 * Translate the 3D object by a distance along its Z-axis in local space.
		 *
		 * @param {number} distance - The distance in world units.
		 * @return {Object3D} A reference to this instance.
		 */ translateZ(distance) {
	        return this.translateOnAxis(_zAxis, distance);
	    }
	    /**
		 * Converts the given vector from this 3D object's local space to world space.
		 *
		 * @param {Vector3} vector - The vector to convert.
		 * @return {Vector3} The converted vector.
		 */ localToWorld(vector) {
	        this.updateWorldMatrix(true, false);
	        return vector.applyMatrix4(this.matrixWorld);
	    }
	    /**
		 * Converts the given vector from this 3D object's word space to local space.
		 *
		 * @param {Vector3} vector - The vector to convert.
		 * @return {Vector3} The converted vector.
		 */ worldToLocal(vector) {
	        this.updateWorldMatrix(true, false);
	        return vector.applyMatrix4(_m1$1$1.copy(this.matrixWorld).invert());
	    }
	    /**
		 * Rotates the object to face a point in world space.
		 *
		 * This method does not support objects having non-uniformly-scaled parent(s).
		 *
		 * @param {number|Vector3} x - The x coordinate in world space. Alternatively, a vector representing a position in world space
		 * @param {number} [y] - The y coordinate in world space.
		 * @param {number} [z] - The z coordinate in world space.
		 */ lookAt(x, y, z) {
	        // This method does not support objects having non-uniformly-scaled parent(s)
	        if (x.isVector3) {
	            _target.copy(x);
	        } else {
	            _target.set(x, y, z);
	        }
	        const parent = this.parent;
	        this.updateWorldMatrix(true, false);
	        _position$3.setFromMatrixPosition(this.matrixWorld);
	        if (this.isCamera || this.isLight) {
	            _m1$1$1.lookAt(_position$3, _target, this.up);
	        } else {
	            _m1$1$1.lookAt(_target, _position$3, this.up);
	        }
	        this.quaternion.setFromRotationMatrix(_m1$1$1);
	        if (parent) {
	            _m1$1$1.extractRotation(parent.matrixWorld);
	            _q1.setFromRotationMatrix(_m1$1$1);
	            this.quaternion.premultiply(_q1.invert());
	        }
	    }
	    /**
		 * Adds the given 3D object as a child to this 3D object. An arbitrary number of
		 * objects may be added. Any current parent on an object passed in here will be
		 * removed, since an object can have at most one parent.
		 *
		 * @fires Object3D#added
		 * @fires Object3D#childadded
		 * @param {Object3D} object - The 3D object to add.
		 * @return {Object3D} A reference to this instance.
		 */ add(object) {
	        if (arguments.length > 1) {
	            for(let i = 0; i < arguments.length; i++){
	                this.add(arguments[i]);
	            }
	            return this;
	        }
	        if (object === this) {
	            console.error('THREE.Object3D.add: object can\'t be added as a child of itself.', object);
	            return this;
	        }
	        if (object && object.isObject3D) {
	            object.removeFromParent();
	            object.parent = this;
	            this.children.push(object);
	            object.dispatchEvent(_addedEvent);
	            _childaddedEvent.child = object;
	            this.dispatchEvent(_childaddedEvent);
	            _childaddedEvent.child = null;
	        } else {
	            console.error('THREE.Object3D.add: object not an instance of THREE.Object3D.', object);
	        }
	        return this;
	    }
	    /**
		 * Removes the given 3D object as child from this 3D object.
		 * An arbitrary number of objects may be removed.
		 *
		 * @fires Object3D#removed
		 * @fires Object3D#childremoved
		 * @param {Object3D} object - The 3D object to remove.
		 * @return {Object3D} A reference to this instance.
		 */ remove(object) {
	        if (arguments.length > 1) {
	            for(let i = 0; i < arguments.length; i++){
	                this.remove(arguments[i]);
	            }
	            return this;
	        }
	        const index = this.children.indexOf(object);
	        if (index !== -1) {
	            object.parent = null;
	            this.children.splice(index, 1);
	            object.dispatchEvent(_removedEvent);
	            _childremovedEvent.child = object;
	            this.dispatchEvent(_childremovedEvent);
	            _childremovedEvent.child = null;
	        }
	        return this;
	    }
	    /**
		 * Removes this 3D object from its current parent.
		 *
		 * @fires Object3D#removed
		 * @fires Object3D#childremoved
		 * @return {Object3D} A reference to this instance.
		 */ removeFromParent() {
	        const parent = this.parent;
	        if (parent !== null) {
	            parent.remove(this);
	        }
	        return this;
	    }
	    /**
		 * Removes all child objects.
		 *
		 * @fires Object3D#removed
		 * @fires Object3D#childremoved
		 * @return {Object3D} A reference to this instance.
		 */ clear() {
	        return this.remove(...this.children);
	    }
	    /**
		 * Adds the given 3D object as a child of this 3D object, while maintaining the object's world
		 * transform. This method does not support scene graphs having non-uniformly-scaled nodes(s).
		 *
		 * @fires Object3D#added
		 * @fires Object3D#childadded
		 * @param {Object3D} object - The 3D object to attach.
		 * @return {Object3D} A reference to this instance.
		 */ attach(object) {
	        // adds object as a child of this, while maintaining the object's world transform
	        // Note: This method does not support scene graphs having non-uniformly-scaled nodes(s)
	        this.updateWorldMatrix(true, false);
	        _m1$1$1.copy(this.matrixWorld).invert();
	        if (object.parent !== null) {
	            object.parent.updateWorldMatrix(true, false);
	            _m1$1$1.multiply(object.parent.matrixWorld);
	        }
	        object.applyMatrix4(_m1$1$1);
	        object.removeFromParent();
	        object.parent = this;
	        this.children.push(object);
	        object.updateWorldMatrix(false, true);
	        object.dispatchEvent(_addedEvent);
	        _childaddedEvent.child = object;
	        this.dispatchEvent(_childaddedEvent);
	        _childaddedEvent.child = null;
	        return this;
	    }
	    /**
		 * Searches through the 3D object and its children, starting with the 3D object
		 * itself, and returns the first with a matching ID.
		 *
		 * @param {number} id - The id.
		 * @return {Object3D|undefined} The found 3D object. Returns `undefined` if no 3D object has been found.
		 */ getObjectById(id) {
	        return this.getObjectByProperty('id', id);
	    }
	    /**
		 * Searches through the 3D object and its children, starting with the 3D object
		 * itself, and returns the first with a matching name.
		 *
		 * @param {string} name - The name.
		 * @return {Object3D|undefined} The found 3D object. Returns `undefined` if no 3D object has been found.
		 */ getObjectByName(name) {
	        return this.getObjectByProperty('name', name);
	    }
	    /**
		 * Searches through the 3D object and its children, starting with the 3D object
		 * itself, and returns the first with a matching property value.
		 *
		 * @param {string} name - The name of the property.
		 * @param {any} value - The value.
		 * @return {Object3D|undefined} The found 3D object. Returns `undefined` if no 3D object has been found.
		 */ getObjectByProperty(name, value) {
	        if (this[name] === value) return this;
	        for(let i = 0, l = this.children.length; i < l; i++){
	            const child = this.children[i];
	            const object = child.getObjectByProperty(name, value);
	            if (object !== undefined) {
	                return object;
	            }
	        }
	        return undefined;
	    }
	    /**
		 * Searches through the 3D object and its children, starting with the 3D object
		 * itself, and returns all 3D objects with a matching property value.
		 *
		 * @param {string} name - The name of the property.
		 * @param {any} value - The value.
		 * @param {Array<Object3D>} result - The method stores the result in this array.
		 * @return {Array<Object3D>} The found 3D objects.
		 */ getObjectsByProperty(name, value, result = []) {
	        if (this[name] === value) result.push(this);
	        const children = this.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            children[i].getObjectsByProperty(name, value, result);
	        }
	        return result;
	    }
	    /**
		 * Returns a vector representing the position of the 3D object in world space.
		 *
		 * @param {Vector3} target - The target vector the result is stored to.
		 * @return {Vector3} The 3D object's position in world space.
		 */ getWorldPosition(target) {
	        this.updateWorldMatrix(true, false);
	        return target.setFromMatrixPosition(this.matrixWorld);
	    }
	    /**
		 * Returns a Quaternion representing the position of the 3D object in world space.
		 *
		 * @param {Quaternion} target - The target Quaternion the result is stored to.
		 * @return {Quaternion} The 3D object's rotation in world space.
		 */ getWorldQuaternion(target) {
	        this.updateWorldMatrix(true, false);
	        this.matrixWorld.decompose(_position$3, target, _scale$2);
	        return target;
	    }
	    /**
		 * Returns a vector representing the scale of the 3D object in world space.
		 *
		 * @param {Vector3} target - The target vector the result is stored to.
		 * @return {Vector3} The 3D object's scale in world space.
		 */ getWorldScale(target) {
	        this.updateWorldMatrix(true, false);
	        this.matrixWorld.decompose(_position$3, _quaternion$2, target);
	        return target;
	    }
	    /**
		 * Returns a vector representing the ("look") direction of the 3D object in world space.
		 *
		 * @param {Vector3} target - The target vector the result is stored to.
		 * @return {Vector3} The 3D object's direction in world space.
		 */ getWorldDirection(target) {
	        this.updateWorldMatrix(true, false);
	        const e = this.matrixWorld.elements;
	        return target.set(e[8], e[9], e[10]).normalize();
	    }
	    /**
		 * Abstract method to get intersections between a casted ray and this
		 * 3D object. Renderable 3D objects such as {@link Mesh}, {@link Line} or {@link Points}
		 * implement this method in order to use raycasting.
		 *
		 * @abstract
		 * @param {Raycaster} raycaster - The raycaster.
		 * @param {Array<Object>} intersects - An array holding the result of the method.
		 */ raycast() {}
	    /**
		 * Executes the callback on this 3D object and all descendants.
		 *
		 * Note: Modifying the scene graph inside the callback is discouraged.
		 *
		 * @param {Function} callback - A callback function that allows to process the current 3D object.
		 */ traverse(callback) {
	        callback(this);
	        const children = this.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            children[i].traverse(callback);
	        }
	    }
	    /**
		 * Like {@link Object3D#traverse}, but the callback will only be executed for visible 3D objects.
		 * Descendants of invisible 3D objects are not traversed.
		 *
		 * Note: Modifying the scene graph inside the callback is discouraged.
		 *
		 * @param {Function} callback - A callback function that allows to process the current 3D object.
		 */ traverseVisible(callback) {
	        if (this.visible === false) return;
	        callback(this);
	        const children = this.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            children[i].traverseVisible(callback);
	        }
	    }
	    /**
		 * Like {@link Object3D#traverse}, but the callback will only be executed for all ancestors.
		 *
		 * Note: Modifying the scene graph inside the callback is discouraged.
		 *
		 * @param {Function} callback - A callback function that allows to process the current 3D object.
		 */ traverseAncestors(callback) {
	        const parent = this.parent;
	        if (parent !== null) {
	            callback(parent);
	            parent.traverseAncestors(callback);
	        }
	    }
	    /**
		 * Updates the transformation matrix in local space by computing it from the current
		 * position, rotation and scale values.
		 */ updateMatrix() {
	        this.matrix.compose(this.position, this.quaternion, this.scale);
	        this.matrixWorldNeedsUpdate = true;
	    }
	    /**
		 * Updates the transformation matrix in world space of this 3D objects and its descendants.
		 *
		 * To ensure correct results, this method also recomputes the 3D object's transformation matrix in
		 * local space. The computation of the local and world matrix can be controlled with the
		 * {@link Object3D#matrixAutoUpdate} and {@link Object3D#matrixWorldAutoUpdate} flags which are both
		 * `true` by default.  Set these flags to `false` if you need more control over the update matrix process.
		 *
		 * @param {boolean} [force=false] - When set to `true`, a recomputation of world matrices is forced even
		 * when {@link Object3D#matrixWorldAutoUpdate} is set to `false`.
		 */ updateMatrixWorld(force) {
	        if (this.matrixAutoUpdate) this.updateMatrix();
	        if (this.matrixWorldNeedsUpdate || force) {
	            if (this.matrixWorldAutoUpdate === true) {
	                if (this.parent === null) {
	                    this.matrixWorld.copy(this.matrix);
	                } else {
	                    this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
	                }
	            }
	            this.matrixWorldNeedsUpdate = false;
	            force = true;
	        }
	        // make sure descendants are updated if required
	        const children = this.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            const child = children[i];
	            child.updateMatrixWorld(force);
	        }
	    }
	    /**
		 * An alternative version of {@link Object3D#updateMatrixWorld} with more control over the
		 * update of ancestor and descendant nodes.
		 *
		 * @param {boolean} [updateParents=false] Whether ancestor nodes should be updated or not.
		 * @param {boolean} [updateChildren=false] Whether descendant nodes should be updated or not.
		 */ updateWorldMatrix(updateParents, updateChildren) {
	        const parent = this.parent;
	        if (updateParents === true && parent !== null) {
	            parent.updateWorldMatrix(true, false);
	        }
	        if (this.matrixAutoUpdate) this.updateMatrix();
	        if (this.matrixWorldAutoUpdate === true) {
	            if (this.parent === null) {
	                this.matrixWorld.copy(this.matrix);
	            } else {
	                this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
	            }
	        }
	        // make sure descendants are updated
	        if (updateChildren === true) {
	            const children = this.children;
	            for(let i = 0, l = children.length; i < l; i++){
	                const child = children[i];
	                child.updateWorldMatrix(false, true);
	            }
	        }
	    }
	    /**
		 * Serializes the 3D object into JSON.
		 *
		 * @param {?(Object|string)} meta - An optional value holding meta information about the serialization.
		 * @return {Object} A JSON object representing the serialized 3D object.
		 * @see {@link ObjectLoader#parse}
		 */ toJSON(meta) {
	        // meta is a string when called from JSON.stringify
	        const isRootObject = meta === undefined || typeof meta === 'string';
	        const output = {};
	        // meta is a hash used to collect geometries, materials.
	        // not providing it implies that this is the root object
	        // being serialized.
	        if (isRootObject) {
	            // initialize meta obj
	            meta = {
	                geometries: {},
	                materials: {},
	                textures: {},
	                images: {},
	                shapes: {},
	                skeletons: {},
	                animations: {},
	                nodes: {}
	            };
	            output.metadata = {
	                version: 4.6,
	                type: 'Object',
	                generator: 'Object3D.toJSON'
	            };
	        }
	        // standard Object3D serialization
	        const object = {};
	        object.uuid = this.uuid;
	        object.type = this.type;
	        if (this.name !== '') object.name = this.name;
	        if (this.castShadow === true) object.castShadow = true;
	        if (this.receiveShadow === true) object.receiveShadow = true;
	        if (this.visible === false) object.visible = false;
	        if (this.frustumCulled === false) object.frustumCulled = false;
	        if (this.renderOrder !== 0) object.renderOrder = this.renderOrder;
	        if (Object.keys(this.userData).length > 0) object.userData = this.userData;
	        object.layers = this.layers.mask;
	        object.matrix = this.matrix.toArray();
	        object.up = this.up.toArray();
	        if (this.matrixAutoUpdate === false) object.matrixAutoUpdate = false;
	        // object specific properties
	        if (this.isInstancedMesh) {
	            object.type = 'InstancedMesh';
	            object.count = this.count;
	            object.instanceMatrix = this.instanceMatrix.toJSON();
	            if (this.instanceColor !== null) object.instanceColor = this.instanceColor.toJSON();
	        }
	        if (this.isBatchedMesh) {
	            object.type = 'BatchedMesh';
	            object.perObjectFrustumCulled = this.perObjectFrustumCulled;
	            object.sortObjects = this.sortObjects;
	            object.drawRanges = this._drawRanges;
	            object.reservedRanges = this._reservedRanges;
	            object.visibility = this._visibility;
	            object.active = this._active;
	            object.bounds = this._bounds.map((bound)=>({
	                    boxInitialized: bound.boxInitialized,
	                    boxMin: bound.box.min.toArray(),
	                    boxMax: bound.box.max.toArray(),
	                    sphereInitialized: bound.sphereInitialized,
	                    sphereRadius: bound.sphere.radius,
	                    sphereCenter: bound.sphere.center.toArray()
	                }));
	            object.maxInstanceCount = this._maxInstanceCount;
	            object.maxVertexCount = this._maxVertexCount;
	            object.maxIndexCount = this._maxIndexCount;
	            object.geometryInitialized = this._geometryInitialized;
	            object.geometryCount = this._geometryCount;
	            object.matricesTexture = this._matricesTexture.toJSON(meta);
	            if (this._colorsTexture !== null) object.colorsTexture = this._colorsTexture.toJSON(meta);
	            if (this.boundingSphere !== null) {
	                object.boundingSphere = {
	                    center: object.boundingSphere.center.toArray(),
	                    radius: object.boundingSphere.radius
	                };
	            }
	            if (this.boundingBox !== null) {
	                object.boundingBox = {
	                    min: object.boundingBox.min.toArray(),
	                    max: object.boundingBox.max.toArray()
	                };
	            }
	        }
	        //
	        function serialize(library, element) {
	            if (library[element.uuid] === undefined) {
	                library[element.uuid] = element.toJSON(meta);
	            }
	            return element.uuid;
	        }
	        if (this.isScene) {
	            if (this.background) {
	                if (this.background.isColor) {
	                    object.background = this.background.toJSON();
	                } else if (this.background.isTexture) {
	                    object.background = this.background.toJSON(meta).uuid;
	                }
	            }
	            if (this.environment && this.environment.isTexture && this.environment.isRenderTargetTexture !== true) {
	                object.environment = this.environment.toJSON(meta).uuid;
	            }
	        } else if (this.isMesh || this.isLine || this.isPoints) {
	            object.geometry = serialize(meta.geometries, this.geometry);
	            const parameters = this.geometry.parameters;
	            if (parameters !== undefined && parameters.shapes !== undefined) {
	                const shapes = parameters.shapes;
	                if (Array.isArray(shapes)) {
	                    for(let i = 0, l = shapes.length; i < l; i++){
	                        const shape = shapes[i];
	                        serialize(meta.shapes, shape);
	                    }
	                } else {
	                    serialize(meta.shapes, shapes);
	                }
	            }
	        }
	        if (this.isSkinnedMesh) {
	            object.bindMode = this.bindMode;
	            object.bindMatrix = this.bindMatrix.toArray();
	            if (this.skeleton !== undefined) {
	                serialize(meta.skeletons, this.skeleton);
	                object.skeleton = this.skeleton.uuid;
	            }
	        }
	        if (this.material !== undefined) {
	            if (Array.isArray(this.material)) {
	                const uuids = [];
	                for(let i = 0, l = this.material.length; i < l; i++){
	                    uuids.push(serialize(meta.materials, this.material[i]));
	                }
	                object.material = uuids;
	            } else {
	                object.material = serialize(meta.materials, this.material);
	            }
	        }
	        //
	        if (this.children.length > 0) {
	            object.children = [];
	            for(let i = 0; i < this.children.length; i++){
	                object.children.push(this.children[i].toJSON(meta).object);
	            }
	        }
	        //
	        if (this.animations.length > 0) {
	            object.animations = [];
	            for(let i = 0; i < this.animations.length; i++){
	                const animation = this.animations[i];
	                object.animations.push(serialize(meta.animations, animation));
	            }
	        }
	        if (isRootObject) {
	            const geometries = extractFromCache(meta.geometries);
	            const materials = extractFromCache(meta.materials);
	            const textures = extractFromCache(meta.textures);
	            const images = extractFromCache(meta.images);
	            const shapes = extractFromCache(meta.shapes);
	            const skeletons = extractFromCache(meta.skeletons);
	            const animations = extractFromCache(meta.animations);
	            const nodes = extractFromCache(meta.nodes);
	            if (geometries.length > 0) output.geometries = geometries;
	            if (materials.length > 0) output.materials = materials;
	            if (textures.length > 0) output.textures = textures;
	            if (images.length > 0) output.images = images;
	            if (shapes.length > 0) output.shapes = shapes;
	            if (skeletons.length > 0) output.skeletons = skeletons;
	            if (animations.length > 0) output.animations = animations;
	            if (nodes.length > 0) output.nodes = nodes;
	        }
	        output.object = object;
	        return output;
	        // extract data from the cache hash
	        // remove metadata on each item
	        // and return as array
	        function extractFromCache(cache) {
	            const values = [];
	            for(const key in cache){
	                const data = cache[key];
	                delete data.metadata;
	                values.push(data);
	            }
	            return values;
	        }
	    }
	    /**
		 * Returns a new 3D object with copied values from this instance.
		 *
		 * @param {boolean} [recursive=true] - When set to `true`, descendants of the 3D object are also cloned.
		 * @return {Object3D} A clone of this instance.
		 */ clone(recursive) {
	        return new this.constructor().copy(this, recursive);
	    }
	    /**
		 * Copies the values of the given 3D object to this instance.
		 *
		 * @param {Object3D} source - The 3D object to copy.
		 * @param {boolean} [recursive=true] - When set to `true`, descendants of the 3D object are cloned.
		 * @return {Object3D} A reference to this instance.
		 */ copy(source, recursive = true) {
	        this.name = source.name;
	        this.up.copy(source.up);
	        this.position.copy(source.position);
	        this.rotation.order = source.rotation.order;
	        this.quaternion.copy(source.quaternion);
	        this.scale.copy(source.scale);
	        this.matrix.copy(source.matrix);
	        this.matrixWorld.copy(source.matrixWorld);
	        this.matrixAutoUpdate = source.matrixAutoUpdate;
	        this.matrixWorldAutoUpdate = source.matrixWorldAutoUpdate;
	        this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
	        this.layers.mask = source.layers.mask;
	        this.visible = source.visible;
	        this.castShadow = source.castShadow;
	        this.receiveShadow = source.receiveShadow;
	        this.frustumCulled = source.frustumCulled;
	        this.renderOrder = source.renderOrder;
	        this.animations = source.animations.slice();
	        this.userData = JSON.parse(JSON.stringify(source.userData));
	        if (recursive === true) {
	            for(let i = 0; i < source.children.length; i++){
	                const child = source.children[i];
	                this.add(child.clone());
	            }
	        }
	        return this;
	    }
	    /**
		 * Constructs a new 3D object.
		 */ constructor(){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isObject3D = true;
	        /**
			 * The ID of the 3D object.
			 *
			 * @name Object3D#id
			 * @type {number}
			 * @readonly
			 */ Object.defineProperty(this, 'id', {
	            value: _object3DId++
	        });
	        /**
			 * The UUID of the 3D object.
			 *
			 * @type {string}
			 * @readonly
			 */ this.uuid = generateUUID();
	        /**
			 * The name of the 3D object.
			 *
			 * @type {string}
			 */ this.name = '';
	        /**
			 * The type property is used for detecting the object type
			 * in context of serialization/deserialization.
			 *
			 * @type {string}
			 * @readonly
			 */ this.type = 'Object3D';
	        /**
			 * A reference to the parent object.
			 *
			 * @type {?Object3D}
			 * @default null
			 */ this.parent = null;
	        /**
			 * An array holding the child 3D objects of this instance.
			 *
			 * @type {Array<Object3D>}
			 */ this.children = [];
	        /**
			 * Defines the `up` direction of the 3D object which influences
			 * the orientation via methods like {@link Object3D#lookAt}.
			 *
			 * The default values for all 3D objects is defined by `Object3D.DEFAULT_UP`.
			 *
			 * @type {Vector3}
			 */ this.up = Object3D.DEFAULT_UP.clone();
	        const position = new Vector3();
	        const rotation = new Euler();
	        const quaternion = new Quaternion();
	        const scale = new Vector3(1, 1, 1);
	        function onRotationChange() {
	            quaternion.setFromEuler(rotation, false);
	        }
	        function onQuaternionChange() {
	            rotation.setFromQuaternion(quaternion, undefined, false);
	        }
	        rotation._onChange(onRotationChange);
	        quaternion._onChange(onQuaternionChange);
	        Object.defineProperties(this, {
	            /**
				 * Represents the object's local position.
				 *
				 * @name Object3D#position
				 * @type {Vector3}
				 * @default (0,0,0)
				 */ position: {
	                configurable: true,
	                enumerable: true,
	                value: position
	            },
	            /**
				 * Represents the object's local rotation as Euler angles, in radians.
				 *
				 * @name Object3D#rotation
				 * @type {Euler}
				 * @default (0,0,0)
				 */ rotation: {
	                configurable: true,
	                enumerable: true,
	                value: rotation
	            },
	            /**
				 * Represents the object's local rotation as Quaternions.
				 *
				 * @name Object3D#quaternion
				 * @type {Quaternion}
				 */ quaternion: {
	                configurable: true,
	                enumerable: true,
	                value: quaternion
	            },
	            /**
				 * Represents the object's local scale.
				 *
				 * @name Object3D#scale
				 * @type {Vector3}
				 * @default (1,1,1)
				 */ scale: {
	                configurable: true,
	                enumerable: true,
	                value: scale
	            },
	            /**
				 * Represents the object's model-view matrix.
				 *
				 * @name Object3D#modelViewMatrix
				 * @type {Matrix4}
				 */ modelViewMatrix: {
	                value: new Matrix4()
	            },
	            /**
				 * Represents the object's normal matrix.
				 *
				 * @name Object3D#normalMatrix
				 * @type {Matrix3}
				 */ normalMatrix: {
	                value: new Matrix3()
	            }
	        });
	        /**
			 * Represents the object's transformation matrix in local space.
			 *
			 * @type {Matrix4}
			 */ this.matrix = new Matrix4();
	        /**
			 * Represents the object's transformation matrix in world space.
			 * If the 3D object has no parent, then it's identical to the local transformation matrix
			 *
			 * @type {Matrix4}
			 */ this.matrixWorld = new Matrix4();
	        /**
			 * When set to `true`, the engine automatically computes the local matrix from position,
			 * rotation and scale every frame.
			 *
			 * The default values for all 3D objects is defined by `Object3D.DEFAULT_MATRIX_AUTO_UPDATE`.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.matrixAutoUpdate = Object3D.DEFAULT_MATRIX_AUTO_UPDATE;
	        /**
			 * When set to `true`, the engine automatically computes the world matrix from the current local
			 * matrix and the object's transformation hierarchy.
			 *
			 * The default values for all 3D objects is defined by `Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE`.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.matrixWorldAutoUpdate = Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE; // checked by the renderer
	        /**
			 * When set to `true`, it calculates the world matrix in that frame and resets this property
			 * to `false`.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.matrixWorldNeedsUpdate = false;
	        /**
			 * The layer membership of the 3D object. The 3D object is only visible if it has
			 * at least one layer in common with the camera in use. This property can also be
			 * used to filter out unwanted objects in ray-intersection tests when using {@link Raycaster}.
			 *
			 * @type {Layers}
			 */ this.layers = new Layers();
	        /**
			 * When set to `true`, the 3D object gets rendered.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.visible = true;
	        /**
			 * When set to `true`, the 3D object gets rendered into shadow maps.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.castShadow = false;
	        /**
			 * When set to `true`, the 3D object is affected by shadows in the scene.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.receiveShadow = false;
	        /**
			 * When set to `true`, the 3D object is honored by view frustum culling.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.frustumCulled = true;
	        /**
			 * This value allows the default rendering order of scene graph objects to be
			 * overridden although opaque and transparent objects remain sorted independently.
			 * When this property is set for an instance of {@link Group},all descendants
			 * objects will be sorted and rendered together. Sorting is from lowest to highest
			 * render order.
			 *
			 * @type {number}
			 * @default 0
			 */ this.renderOrder = 0;
	        /**
			 * An array holding the animation clips of the 3D object.
			 *
			 * @type {Array<AnimationClip>}
			 */ this.animations = [];
	        /**
			 * An object that can be used to store custom data about the 3D object. It
			 * should not hold references to functions as these will not be cloned.
			 *
			 * @type {Object}
			 */ this.userData = {};
	    }
	}
	/**
	 * The default up direction for objects, also used as the default
	 * position for {@link DirectionalLight} and {@link HemisphereLight}.
	 *
	 * @static
	 * @type {Vector3}
	 * @default (0,1,0)
	 */ Object3D.DEFAULT_UP = /*@__PURE__*/ new Vector3(0, 1, 0);
	/**
	 * The default setting for {@link Object3D#matrixAutoUpdate} for
	 * newly created 3D objects.
	 *
	 * @static
	 * @type {boolean}
	 * @default true
	 */ Object3D.DEFAULT_MATRIX_AUTO_UPDATE = true;
	/**
	 * The default setting for {@link Object3D#matrixWorldAutoUpdate} for
	 * newly created 3D objects.
	 *
	 * @static
	 * @type {boolean}
	 * @default true
	 */ Object3D.DEFAULT_MATRIX_WORLD_AUTO_UPDATE = true;
	const _v0$1 = /*@__PURE__*/ new Vector3();
	const _v1$3 = /*@__PURE__*/ new Vector3();
	const _v2$2 = /*@__PURE__*/ new Vector3();
	const _v3$2 = /*@__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();
	const _v40 = /*@__PURE__*/ new Vector4();
	const _v41 = /*@__PURE__*/ new Vector4();
	const _v42 = /*@__PURE__*/ new Vector4();
	/**
	 * A geometric triangle as defined by three vectors representing its three corners.
	 */ class Triangle {
	    /**
		 * Computes the normal vector of a triangle.
		 *
		 * @param {Vector3} a - The first corner of the triangle.
		 * @param {Vector3} b - The second corner of the triangle.
		 * @param {Vector3} c - The third corner of the triangle.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The triangle's normal.
		 */ 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);
	    }
	    /**
		 * Computes a barycentric coordinates from the given vector.
		 * Returns `null` if the triangle is degenerate.
		 *
		 * @param {Vector3} point - A point in 3D space.
		 * @param {Vector3} a - The first corner of the triangle.
		 * @param {Vector3} b - The second corner of the triangle.
		 * @param {Vector3} c - The third corner of the triangle.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The barycentric coordinates for the given point
		 */ static getBarycoord(point, a, b, c, target) {
	        // based on: http://www.blackpawn.com/texts/pointinpoly/default.html
	        _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) {
	            target.set(0, 0, 0);
	            return null;
	        }
	        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);
	    }
	    /**
		 * Returns `true` if the given point, when projected onto the plane of the
		 * triangle, lies within the triangle.
		 *
		 * @param {Vector3} point - The point in 3D space to test.
		 * @param {Vector3} a - The first corner of the triangle.
		 * @param {Vector3} b - The second corner of the triangle.
		 * @param {Vector3} c - The third corner of the triangle.
		 * @return {boolean} Whether the given point, when projected onto the plane of the
		 * triangle, lies within the triangle or not.
		 */ static containsPoint(point, a, b, c) {
	        // if the triangle is degenerate then we can't contain a point
	        if (this.getBarycoord(point, a, b, c, _v3$2) === null) {
	            return false;
	        }
	        return _v3$2.x >= 0 && _v3$2.y >= 0 && _v3$2.x + _v3$2.y <= 1;
	    }
	    /**
		 * Computes the value barycentrically interpolated for the given point on the
		 * triangle. Returns `null` if the triangle is degenerate.
		 *
		 * @param {Vector3} point - Position of interpolated point.
		 * @param {Vector3} p1 - The first corner of the triangle.
		 * @param {Vector3} p2 - The second corner of the triangle.
		 * @param {Vector3} p3 - The third corner of the triangle.
		 * @param {Vector3} v1 - Value to interpolate of first vertex.
		 * @param {Vector3} v2 - Value to interpolate of second vertex.
		 * @param {Vector3} v3 - Value to interpolate of third vertex.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The interpolated value.
		 */ static getInterpolation(point, p1, p2, p3, v1, v2, v3, target) {
	        if (this.getBarycoord(point, p1, p2, p3, _v3$2) === null) {
	            target.x = 0;
	            target.y = 0;
	            if ('z' in target) target.z = 0;
	            if ('w' in target) target.w = 0;
	            return null;
	        }
	        target.setScalar(0);
	        target.addScaledVector(v1, _v3$2.x);
	        target.addScaledVector(v2, _v3$2.y);
	        target.addScaledVector(v3, _v3$2.z);
	        return target;
	    }
	    /**
		 * Computes the value barycentrically interpolated for the given attribute and indices.
		 *
		 * @param {BufferAttribute} attr - The attribute to interpolate.
		 * @param {number} i1 - Index of first vertex.
		 * @param {number} i2 - Index of second vertex.
		 * @param {number} i3 - Index of third vertex.
		 * @param {Vector3} barycoord - The barycoordinate value to use to interpolate.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The interpolated attribute value.
		 */ static getInterpolatedAttribute(attr, i1, i2, i3, barycoord, target) {
	        _v40.setScalar(0);
	        _v41.setScalar(0);
	        _v42.setScalar(0);
	        _v40.fromBufferAttribute(attr, i1);
	        _v41.fromBufferAttribute(attr, i2);
	        _v42.fromBufferAttribute(attr, i3);
	        target.setScalar(0);
	        target.addScaledVector(_v40, barycoord.x);
	        target.addScaledVector(_v41, barycoord.y);
	        target.addScaledVector(_v42, barycoord.z);
	        return target;
	    }
	    /**
		 * Returns `true` if the triangle is oriented towards the given direction.
		 *
		 * @param {Vector3} a - The first corner of the triangle.
		 * @param {Vector3} b - The second corner of the triangle.
		 * @param {Vector3} c - The third corner of the triangle.
		 * @param {Vector3} direction - The (normalized) direction vector.
		 * @return {boolean} Whether the triangle is oriented towards the given direction or not.
		 */ 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;
	    }
	    /**
		 * Sets the triangle's vertices by copying the given values.
		 *
		 * @param {Vector3} a - The first corner of the triangle.
		 * @param {Vector3} b - The second corner of the triangle.
		 * @param {Vector3} c - The third corner of the triangle.
		 * @return {Triangle} A reference to this triangle.
		 */ set(a, b, c) {
	        this.a.copy(a);
	        this.b.copy(b);
	        this.c.copy(c);
	        return this;
	    }
	    /**
		 * Sets the triangle's vertices by copying the given array values.
		 *
		 * @param {Array<Vector3>} points - An array with 3D points.
		 * @param {number} i0 - The array index representing the first corner of the triangle.
		 * @param {number} i1 - The array index representing the second corner of the triangle.
		 * @param {number} i2 - The array index representing the third corner of the triangle.
		 * @return {Triangle} A reference to this triangle.
		 */ setFromPointsAndIndices(points, i0, i1, i2) {
	        this.a.copy(points[i0]);
	        this.b.copy(points[i1]);
	        this.c.copy(points[i2]);
	        return this;
	    }
	    /**
		 * Sets the triangle's vertices by copying the given attribute values.
		 *
		 * @param {BufferAttribute} attribute - A buffer attribute with 3D points data.
		 * @param {number} i0 - The attribute index representing the first corner of the triangle.
		 * @param {number} i1 - The attribute index representing the second corner of the triangle.
		 * @param {number} i2 - The attribute index representing the third corner of the triangle.
		 * @return {Triangle} A reference to this triangle.
		 */ setFromAttributeAndIndices(attribute, i0, i1, i2) {
	        this.a.fromBufferAttribute(attribute, i0);
	        this.b.fromBufferAttribute(attribute, i1);
	        this.c.fromBufferAttribute(attribute, i2);
	        return this;
	    }
	    /**
		 * Returns a new triangle with copied values from this instance.
		 *
		 * @return {Triangle} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Copies the values of the given triangle to this instance.
		 *
		 * @param {Triangle} triangle - The triangle to copy.
		 * @return {Triangle} A reference to this triangle.
		 */ copy(triangle) {
	        this.a.copy(triangle.a);
	        this.b.copy(triangle.b);
	        this.c.copy(triangle.c);
	        return this;
	    }
	    /**
		 * Computes the area of the triangle.
		 *
		 * @return {number} The triangle's area.
		 */ getArea() {
	        _v0$1.subVectors(this.c, this.b);
	        _v1$3.subVectors(this.a, this.b);
	        return _v0$1.cross(_v1$3).length() * 0.5;
	    }
	    /**
		 * Computes the midpoint of the triangle.
		 *
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The triangle's midpoint.
		 */ getMidpoint(target) {
	        return target.addVectors(this.a, this.b).add(this.c).multiplyScalar(1 / 3);
	    }
	    /**
		 * Computes the normal of the triangle.
		 *
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The triangle's normal.
		 */ getNormal(target) {
	        return Triangle.getNormal(this.a, this.b, this.c, target);
	    }
	    /**
		 * Computes a plane the triangle lies within.
		 *
		 * @param {Plane} target - The target vector that is used to store the method's result.
		 * @return {Plane} The plane the triangle lies within.
		 */ getPlane(target) {
	        return target.setFromCoplanarPoints(this.a, this.b, this.c);
	    }
	    /**
		 * Computes a barycentric coordinates from the given vector.
		 * Returns `null` if the triangle is degenerate.
		 *
		 * @param {Vector3} point - A point in 3D space.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The barycentric coordinates for the given point
		 */ getBarycoord(point, target) {
	        return Triangle.getBarycoord(point, this.a, this.b, this.c, target);
	    }
	    /**
		 * Computes the value barycentrically interpolated for the given point on the
		 * triangle. Returns `null` if the triangle is degenerate.
		 *
		 * @param {Vector3} point - Position of interpolated point.
		 * @param {Vector3} v1 - Value to interpolate of first vertex.
		 * @param {Vector3} v2 - Value to interpolate of second vertex.
		 * @param {Vector3} v3 - Value to interpolate of third vertex.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The interpolated value.
		 */ getInterpolation(point, v1, v2, v3, target) {
	        return Triangle.getInterpolation(point, this.a, this.b, this.c, v1, v2, v3, target);
	    }
	    /**
		 * Returns `true` if the given point, when projected onto the plane of the
		 * triangle, lies within the triangle.
		 *
		 * @param {Vector3} point - The point in 3D space to test.
		 * @return {boolean} Whether the given point, when projected onto the plane of the
		 * triangle, lies within the triangle or not.
		 */ containsPoint(point) {
	        return Triangle.containsPoint(point, this.a, this.b, this.c);
	    }
	    /**
		 * Returns `true` if the triangle is oriented towards the given direction.
		 *
		 * @param {Vector3} direction - The (normalized) direction vector.
		 * @return {boolean} Whether the triangle is oriented towards the given direction or not.
		 */ isFrontFacing(direction) {
	        return Triangle.isFrontFacing(this.a, this.b, this.c, direction);
	    }
	    /**
		 * Returns `true` if this triangle intersects with the given box.
		 *
		 * @param {Box3} box - The box to intersect.
		 * @return {boolean} Whether this triangle intersects with the given box or not.
		 */ intersectsBox(box) {
	        return box.intersectsTriangle(this);
	    }
	    /**
		 * Returns the closest point on the triangle to the given point.
		 *
		 * @param {Vector3} p - The point to compute the closest point for.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The closest point on the triangle.
		 */ 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);
	    }
	    /**
		 * Returns `true` if this triangle is equal with the given one.
		 *
		 * @param {Triangle} triangle - The triangle to test for equality.
		 * @return {boolean} Whether this triangle is equal with the given one.
		 */ equals(triangle) {
	        return triangle.a.equals(this.a) && triangle.b.equals(this.b) && triangle.c.equals(this.c);
	    }
	    /**
		 * Constructs a new triangle.
		 *
		 * @param {Vector3} [a=(0,0,0)] - The first corner of the triangle.
		 * @param {Vector3} [b=(0,0,0)] - The second corner of the triangle.
		 * @param {Vector3} [c=(0,0,0)] - The third corner of the triangle.
		 */ constructor(a = new Vector3(), b = new Vector3(), c = new Vector3()){
	        /**
			 * The first corner of the triangle.
			 *
			 * @type {Vector3}
			 */ this.a = a;
	        /**
			 * The second corner of the triangle.
			 *
			 * @type {Vector3}
			 */ this.b = b;
	        /**
			 * The third corner of the triangle.
			 *
			 * @type {Vector3}
			 */ this.c = c;
	    }
	}
	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;
	}
	/**
	 * A Color instance is represented by RGB components in the linear <i>working
	 * color space</i>, which defaults to `LinearSRGBColorSpace`. Inputs
	 * conventionally using `SRGBColorSpace` (such as hexadecimals and CSS
	 * strings) are converted to the working color space automatically.
	 *
	 * ```js
	 * // converted automatically from SRGBColorSpace to LinearSRGBColorSpace
	 * const color = new THREE.Color().setHex( 0x112233 );
	 * ```
	 * Source color spaces may be specified explicitly, to ensure correct conversions.
	 * ```js
	 * // assumed already LinearSRGBColorSpace; no conversion
	 * const color = new THREE.Color().setRGB( 0.5, 0.5, 0.5 );
	 *
	 * // converted explicitly from SRGBColorSpace to LinearSRGBColorSpace
	 * const color = new THREE.Color().setRGB( 0.5, 0.5, 0.5, SRGBColorSpace );
	 * ```
	 * If THREE.ColorManagement is disabled, no conversions occur. For details,
	 * see <i>Color management</i>. Iterating through a Color instance will yield
	 * its components (r, g, b) in the corresponding order. A Color can be initialised
	 * in any of the following ways:
	 * ```js
	 * //empty constructor - will default white
	 * const color1 = new THREE.Color();
	 *
	 * //Hexadecimal color (recommended)
	 * const color2 = new THREE.Color( 0xff0000 );
	 *
	 * //RGB string
	 * const color3 = new THREE.Color("rgb(255, 0, 0)");
	 * const color4 = new THREE.Color("rgb(100%, 0%, 0%)");
	 *
	 * //X11 color name - all 140 color names are supported.
	 * //Note the lack of CamelCase in the name
	 * const color5 = new THREE.Color( 'skyblue' );
	 * //HSL string
	 * const color6 = new THREE.Color("hsl(0, 100%, 50%)");
	 *
	 * //Separate RGB values between 0 and 1
	 * const color7 = new THREE.Color( 1, 0, 0 );
	 * ```
	 */ class Color {
	    /**
		 * Sets the colors's components from the given values.
		 *
		 * @param {(number|string|Color)} [r] - The red component of the color. If `g` and `b` are
		 * not provided, it can be hexadecimal triplet, a CSS-style string or another `Color` instance.
		 * @param {number} [g] - The green component.
		 * @param {number} [b] - The blue component.
		 * @return {Color} A reference to this color.
		 */ set(r, g, b) {
	        if (g === undefined && b === undefined) {
	            // r is THREE.Color, hex or string
	            const value = r;
	            if (value && value.isColor) {
	                this.copy(value);
	            } else if (typeof value === 'number') {
	                this.setHex(value);
	            } else if (typeof value === 'string') {
	                this.setStyle(value);
	            }
	        } else {
	            this.setRGB(r, g, b);
	        }
	        return this;
	    }
	    /**
		 * Sets the colors's components to the given scalar value.
		 *
		 * @param {number} scalar - The scalar value.
		 * @return {Color} A reference to this color.
		 */ setScalar(scalar) {
	        this.r = scalar;
	        this.g = scalar;
	        this.b = scalar;
	        return this;
	    }
	    /**
		 * Sets this color from a hexadecimal value.
		 *
		 * @param {number} hex - The hexadecimal value.
		 * @param {string} [colorSpace=SRGBColorSpace] - The color space.
		 * @return {Color} A reference to this color.
		 */ setHex(hex, colorSpace = SRGBColorSpace) {
	        hex = Math.floor(hex);
	        this.r = (hex >> 16 & 255) / 255;
	        this.g = (hex >> 8 & 255) / 255;
	        this.b = (hex & 255) / 255;
	        ColorManagement.toWorkingColorSpace(this, colorSpace);
	        return this;
	    }
	    /**
		 * Sets this color from RGB values.
		 *
		 * @param {number} r - Red channel value between `0.0` and `1.0`.
		 * @param {number} g - Green channel value between `0.0` and `1.0`.
		 * @param {number} b - Blue channel value between `0.0` and `1.0`.
		 * @param {string} [colorSpace=ColorManagement.workingColorSpace] - The color space.
		 * @return {Color} A reference to this color.
		 */ setRGB(r, g, b, colorSpace = ColorManagement.workingColorSpace) {
	        this.r = r;
	        this.g = g;
	        this.b = b;
	        ColorManagement.toWorkingColorSpace(this, colorSpace);
	        return this;
	    }
	    /**
		 * Sets this color from RGB values.
		 *
		 * @param {number} h - Hue value between `0.0` and `1.0`.
		 * @param {number} s - Saturation value between `0.0` and `1.0`.
		 * @param {number} l - Lightness value between `0.0` and `1.0`.
		 * @param {string} [colorSpace=ColorManagement.workingColorSpace] - The color space.
		 * @return {Color} A reference to this color.
		 */ setHSL(h, s, l, colorSpace = ColorManagement.workingColorSpace) {
	        // h,s,l ranges are in 0.0 - 1.0
	        h = euclideanModulo(h, 1);
	        s = clamp$1(s, 0, 1);
	        l = clamp$1(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);
	        }
	        ColorManagement.toWorkingColorSpace(this, colorSpace);
	        return this;
	    }
	    /**
		 * Sets this color from a CSS-style string. For example, `rgb(250, 0,0)`,
		 * `rgb(100%, 0%, 0%)`, `hsl(0, 100%, 50%)`, `#ff0000`, `#f00`, or `red` ( or
		 * any [X11 color name]{@link https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart} -
		 * all 140 color names are supported).
		 *
		 * @param {string} style - Color as a CSS-style string.
		 * @param {string} [colorSpace=SRGBColorSpace] - The color space.
		 * @return {Color} A reference to this color.
		 */ setStyle(style, colorSpace = SRGBColorSpace) {
	        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 = /^(\w+)\(([^\)]*)\)/.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)
	                        handleAlpha(color[4]);
	                        return this.setRGB(Math.min(255, parseInt(color[1], 10)) / 255, Math.min(255, parseInt(color[2], 10)) / 255, Math.min(255, parseInt(color[3], 10)) / 255, colorSpace);
	                    }
	                    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)
	                        handleAlpha(color[4]);
	                        return this.setRGB(Math.min(100, parseInt(color[1], 10)) / 100, Math.min(100, parseInt(color[2], 10)) / 100, Math.min(100, parseInt(color[3], 10)) / 100, colorSpace);
	                    }
	                    break;
	                case 'hsl':
	                case 'hsla':
	                    if (color = /^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
	                        // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
	                        handleAlpha(color[4]);
	                        return this.setHSL(parseFloat(color[1]) / 360, parseFloat(color[2]) / 100, parseFloat(color[3]) / 100, colorSpace);
	                    }
	                    break;
	                default:
	                    console.warn('THREE.Color: Unknown color model ' + style);
	            }
	        } else if (m = /^\#([A-Fa-f\d]+)$/.exec(style)) {
	            // hex color
	            const hex = m[1];
	            const size = hex.length;
	            if (size === 3) {
	                // #ff0
	                return this.setRGB(parseInt(hex.charAt(0), 16) / 15, parseInt(hex.charAt(1), 16) / 15, parseInt(hex.charAt(2), 16) / 15, colorSpace);
	            } else if (size === 6) {
	                // #ff0000
	                return this.setHex(parseInt(hex, 16), colorSpace);
	            } else {
	                console.warn('THREE.Color: Invalid hex color ' + style);
	            }
	        } else if (style && style.length > 0) {
	            return this.setColorName(style, colorSpace);
	        }
	        return this;
	    }
	    /**
		 * Sets this color from a color name. Faster than {@link Color#setStyle} if
		 * you don't need the other CSS-style formats.
		 *
		 * For convenience, the list of names is exposed in `Color.NAMES` as a hash.
		 * ```js
		 * Color.NAMES.aliceblue // returns 0xF0F8FF
		 * ```
		 *
		 * @param {string} style - The color name.
		 * @param {string} [colorSpace=SRGBColorSpace] - The color space.
		 * @return {Color} A reference to this color.
		 */ setColorName(style, colorSpace = SRGBColorSpace) {
	        // color keywords
	        const hex = _colorKeywords[style.toLowerCase()];
	        if (hex !== undefined) {
	            // red
	            this.setHex(hex, colorSpace);
	        } else {
	            // unknown color
	            console.warn('THREE.Color: Unknown color ' + style);
	        }
	        return this;
	    }
	    /**
		 * Returns a new color with copied values from this instance.
		 *
		 * @return {Color} A clone of this instance.
		 */ clone() {
	        return new this.constructor(this.r, this.g, this.b);
	    }
	    /**
		 * Copies the values of the given color to this instance.
		 *
		 * @param {Color} color - The color to copy.
		 * @return {Color} A reference to this color.
		 */ copy(color) {
	        this.r = color.r;
	        this.g = color.g;
	        this.b = color.b;
	        return this;
	    }
	    /**
		 * Copies the given color into this color, and then converts this color from
		 * `SRGBColorSpace` to `LinearSRGBColorSpace`.
		 *
		 * @param {Color} color - The color to copy/convert.
		 * @return {Color} A reference to this color.
		 */ copySRGBToLinear(color) {
	        this.r = SRGBToLinear(color.r);
	        this.g = SRGBToLinear(color.g);
	        this.b = SRGBToLinear(color.b);
	        return this;
	    }
	    /**
		 * Copies the given color into this color, and then converts this color from
		 * `LinearSRGBColorSpace` to `SRGBColorSpace`.
		 *
		 * @param {Color} color - The color to copy/convert.
		 * @return {Color} A reference to this color.
		 */ copyLinearToSRGB(color) {
	        this.r = LinearToSRGB(color.r);
	        this.g = LinearToSRGB(color.g);
	        this.b = LinearToSRGB(color.b);
	        return this;
	    }
	    /**
		 * Converts this color from `SRGBColorSpace` to `LinearSRGBColorSpace`.
		 *
		 * @return {Color} A reference to this color.
		 */ convertSRGBToLinear() {
	        this.copySRGBToLinear(this);
	        return this;
	    }
	    /**
		 * Converts this color from `LinearSRGBColorSpace` to `SRGBColorSpace`.
		 *
		 * @return {Color} A reference to this color.
		 */ convertLinearToSRGB() {
	        this.copyLinearToSRGB(this);
	        return this;
	    }
	    /**
		 * Returns the hexadecimal value of this color.
		 *
		 * @param {string} [colorSpace=SRGBColorSpace] - The color space.
		 * @return {number} The hexadecimal value.
		 */ getHex(colorSpace = SRGBColorSpace) {
	        ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace);
	        return Math.round(clamp$1(_color.r * 255, 0, 255)) * 65536 + Math.round(clamp$1(_color.g * 255, 0, 255)) * 256 + Math.round(clamp$1(_color.b * 255, 0, 255));
	    }
	    /**
		 * Returns the hexadecimal value of this color as a string (for example, 'FFFFFF').
		 *
		 * @param {string} [colorSpace=SRGBColorSpace] - The color space.
		 * @return {string} The hexadecimal value as a string.
		 */ getHexString(colorSpace = SRGBColorSpace) {
	        return ('000000' + this.getHex(colorSpace).toString(16)).slice(-6);
	    }
	    /**
		 * Converts the colors RGB values into the HSL format and stores them into the
		 * given target object.
		 *
		 * @param {{h:0,s:0,l:0}} target - The target object that is used to store the method's result.
		 * @param {string} [colorSpace=ColorManagement.workingColorSpace] - The color space.
		 * @return {{h:number,s:number,l:number}} The HSL representation of this color.
		 */ getHSL(target, colorSpace = ColorManagement.workingColorSpace) {
	        // h,s,l ranges are in 0.0 - 1.0
	        ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace);
	        const r = _color.r, g = _color.g, b = _color.b;
	        const max = Math.max(r, g, b);
	        const min = Math.min(r, g, b);
	        let hue, saturation;
	        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;
	    }
	    /**
		 * Returns the RGB values of this color and stores them into the given target object.
		 *
		 * @param {Color} target - The target color that is used to store the method's result.
		 * @param {string} [colorSpace=ColorManagement.workingColorSpace] - The color space.
		 * @return {Color} The RGB representation of this color.
		 */ getRGB(target, colorSpace = ColorManagement.workingColorSpace) {
	        ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace);
	        target.r = _color.r;
	        target.g = _color.g;
	        target.b = _color.b;
	        return target;
	    }
	    /**
		 * Returns the value of this color as a CSS style string. Example: `rgb(255,0,0)`.
		 *
		 * @param {string} [colorSpace=SRGBColorSpace] - The color space.
		 * @return {string} The CSS representation of this color.
		 */ getStyle(colorSpace = SRGBColorSpace) {
	        ColorManagement.fromWorkingColorSpace(_color.copy(this), colorSpace);
	        const r = _color.r, g = _color.g, b = _color.b;
	        if (colorSpace !== SRGBColorSpace) {
	            // Requires CSS Color Module Level 4 (https://www.w3.org/TR/css-color-4/).
	            return `color(${colorSpace} ${r.toFixed(3)} ${g.toFixed(3)} ${b.toFixed(3)})`;
	        }
	        return `rgb(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)})`;
	    }
	    /**
		 * Adds the given HSL values to this color's values.
		 * Internally, this converts the color's RGB values to HSL, adds HSL
		 * and then converts the color back to RGB.
		 *
		 * @param {number} h - Hue value between `0.0` and `1.0`.
		 * @param {number} s - Saturation value between `0.0` and `1.0`.
		 * @param {number} l - Lightness value between `0.0` and `1.0`.
		 * @return {Color} A reference to this color.
		 */ offsetHSL(h, s, l) {
	        this.getHSL(_hslA);
	        return this.setHSL(_hslA.h + h, _hslA.s + s, _hslA.l + l);
	    }
	    /**
		 * Adds the RGB values of the given color to the RGB values of this color.
		 *
		 * @param {Color} color - The color to add.
		 * @return {Color} A reference to this color.
		 */ add(color) {
	        this.r += color.r;
	        this.g += color.g;
	        this.b += color.b;
	        return this;
	    }
	    /**
		 * Adds the RGB values of the given colors and stores the result in this instance.
		 *
		 * @param {Color} color1 - The first color.
		 * @param {Color} color2 - The second color.
		 * @return {Color} A reference to this color.
		 */ addColors(color1, color2) {
	        this.r = color1.r + color2.r;
	        this.g = color1.g + color2.g;
	        this.b = color1.b + color2.b;
	        return this;
	    }
	    /**
		 * Adds the given scalar value to the RGB values of this color.
		 *
		 * @param {number} s - The scalar to add.
		 * @return {Color} A reference to this color.
		 */ addScalar(s) {
	        this.r += s;
	        this.g += s;
	        this.b += s;
	        return this;
	    }
	    /**
		 * Subtracts the RGB values of the given color from the RGB values of this color.
		 *
		 * @param {Color} color - The color to subtract.
		 * @return {Color} A reference to this color.
		 */ 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;
	    }
	    /**
		 * Multiplies the RGB values of the given color with the RGB values of this color.
		 *
		 * @param {Color} color - The color to multiply.
		 * @return {Color} A reference to this color.
		 */ multiply(color) {
	        this.r *= color.r;
	        this.g *= color.g;
	        this.b *= color.b;
	        return this;
	    }
	    /**
		 * Multiplies the given scalar value with the RGB values of this color.
		 *
		 * @param {number} s - The scalar to multiply.
		 * @return {Color} A reference to this color.
		 */ multiplyScalar(s) {
	        this.r *= s;
	        this.g *= s;
	        this.b *= s;
	        return this;
	    }
	    /**
		 * Linearly interpolates this color's RGB values toward the RGB values of the
		 * given color. The alpha argument can be thought of as the ratio between
		 * the two colors, where `0.0` is this color and `1.0` is the first argument.
		 *
		 * @param {Color} color - The color to converge on.
		 * @param {number} alpha - The interpolation factor in the closed interval `[0,1]`.
		 * @return {Color} A reference to this color.
		 */ 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;
	    }
	    /**
		 * Linearly interpolates between the given colors and stores the result in this instance.
		 * The alpha argument can be thought of as the ratio between the two colors, where `0.0`
		 * is the first and `1.0` is the second color.
		 *
		 * @param {Color} color1 - The first color.
		 * @param {Color} color2 - The second color.
		 * @param {number} alpha - The interpolation factor in the closed interval `[0,1]`.
		 * @return {Color} A reference to this color.
		 */ 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;
	    }
	    /**
		 * Linearly interpolates this color's HSL values toward the HSL values of the
		 * given color. It differs from {@link Color#lerp} by not interpolating straight
		 * from one color to the other, but instead going through all the hues in between
		 * those two colors. The alpha argument can be thought of as the ratio between
		 * the two colors, where 0.0 is this color and 1.0 is the first argument.
		 *
		 * @param {Color} color - The color to converge on.
		 * @param {number} alpha - The interpolation factor in the closed interval `[0,1]`.
		 * @return {Color} A reference to this color.
		 */ lerpHSL(color, alpha) {
	        this.getHSL(_hslA);
	        color.getHSL(_hslB);
	        const h = lerp$1(_hslA.h, _hslB.h, alpha);
	        const s = lerp$1(_hslA.s, _hslB.s, alpha);
	        const l = lerp$1(_hslA.l, _hslB.l, alpha);
	        this.setHSL(h, s, l);
	        return this;
	    }
	    /**
		 * Sets the color's RGB components from the given 3D vector.
		 *
		 * @param {Vector3} v - The vector to set.
		 * @return {Color} A reference to this color.
		 */ setFromVector3(v) {
	        this.r = v.x;
	        this.g = v.y;
	        this.b = v.z;
	        return this;
	    }
	    /**
		 * Transforms this color with the given 3x3 matrix.
		 *
		 * @param {Matrix3} m - The matrix.
		 * @return {Color} A reference to this color.
		 */ applyMatrix3(m) {
	        const r = this.r, g = this.g, b = this.b;
	        const e = m.elements;
	        this.r = e[0] * r + e[3] * g + e[6] * b;
	        this.g = e[1] * r + e[4] * g + e[7] * b;
	        this.b = e[2] * r + e[5] * g + e[8] * b;
	        return this;
	    }
	    /**
		 * Returns `true` if this color is equal with the given one.
		 *
		 * @param {Color} c - The color to test for equality.
		 * @return {boolean} Whether this bounding color is equal with the given one.
		 */ equals(c) {
	        return c.r === this.r && c.g === this.g && c.b === this.b;
	    }
	    /**
		 * Sets this color's RGB components from the given array.
		 *
		 * @param {Array<number>} array - An array holding the RGB values.
		 * @param {number} [offset=0] - The offset into the array.
		 * @return {Color} A reference to this color.
		 */ fromArray(array, offset = 0) {
	        this.r = array[offset];
	        this.g = array[offset + 1];
	        this.b = array[offset + 2];
	        return this;
	    }
	    /**
		 * Writes the RGB components of this color to the given array. If no array is provided,
		 * the method returns a new instance.
		 *
		 * @param {Array<number>} [array=[]] - The target array holding the color components.
		 * @param {number} [offset=0] - Index of the first element in the array.
		 * @return {Array<number>} The color components.
		 */ toArray(array = [], offset = 0) {
	        array[offset] = this.r;
	        array[offset + 1] = this.g;
	        array[offset + 2] = this.b;
	        return array;
	    }
	    /**
		 * Sets the components of this color from the given buffer attribute.
		 *
		 * @param {BufferAttribute} attribute - The buffer attribute holding color data.
		 * @param {number} index - The index into the attribute.
		 * @return {Color} A reference to this color.
		 */ fromBufferAttribute(attribute, index) {
	        this.r = attribute.getX(index);
	        this.g = attribute.getY(index);
	        this.b = attribute.getZ(index);
	        return this;
	    }
	    /**
		 * This methods defines the serialization result of this class. Returns the color
		 * as a hexadecimal value.
		 *
		 * @return {number} The hexadecimal value.
		 */ toJSON() {
	        return this.getHex();
	    }
	    *[Symbol.iterator]() {
	        yield this.r;
	        yield this.g;
	        yield this.b;
	    }
	    /**
		 * Constructs a new color.
		 *
		 * Note that standard method of specifying color in three.js is with a hexadecimal triplet,
		 * and that method is used throughout the rest of the documentation.
		 *
		 * @param {(number|string|Color)} [r] - The red component of the color. If `g` and `b` are
		 * not provided, it can be hexadecimal triplet, a CSS-style string or another `Color` instance.
		 * @param {number} [g] - The green component.
		 * @param {number} [b] - The blue component.
		 */ constructor(r, g, b){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isColor = true;
	        /**
			 * The red component.
			 *
			 * @type {number}
			 * @default 1
			 */ this.r = 1;
	        /**
			 * The green component.
			 *
			 * @type {number}
			 * @default 1
			 */ this.g = 1;
	        /**
			 * The blue component.
			 *
			 * @type {number}
			 * @default 1
			 */ this.b = 1;
	        return this.set(r, g, b);
	    }
	}
	const _color = /*@__PURE__*/ new Color();
	/**
	 * A dictionary with X11 color names.
	 *
	 * Note that multiple words such as Dark Orange become the string 'darkorange'.
	 *
	 * @static
	 * @type {Object}
	 */ Color.NAMES = _colorKeywords;
	let _materialId = 0;
	/**
	 * Abstract base class for materials.
	 *
	 * Materials define the appearance of renderable 3D objects.
	 *
	 * @abstract
	 * @augments EventDispatcher
	 */ let Material$1 = class Material extends EventDispatcher {
	    /**
		 * Sets the alpha value to be used when running an alpha test. The material
		 * will not be rendered if the opacity is lower than this value.
		 *
		 * @type {number}
		 * @readonly
		 * @default 0
		 */ get alphaTest() {
	        return this._alphaTest;
	    }
	    set alphaTest(value) {
	        if (this._alphaTest > 0 !== value > 0) {
	            this.version++;
	        }
	        this._alphaTest = value;
	    }
	    /**
		 * An optional callback that is executed immediately before the material is used to render a 3D object.
		 *
		 * This method can only be used when rendering with {@link WebGLRenderer}.
		 *
		 * @param {WebGLRenderer} renderer - The renderer.
		 * @param {Scene} scene - The scene.
		 * @param {Camera} camera - The camera that is used to render the scene.
		 * @param {BufferGeometry} geometry - The 3D object's geometry.
		 * @param {Object3D} object - The 3D object.
		 * @param {Object} group - The geometry group data.
		 */ onBeforeRender() {}
	    /**
		 * An optional callback that is executed immediately before the shader
		 * program is compiled. This function is called with the shader source code
		 * as a parameter. Useful for the modification of built-in materials.
		 *
		 * This method can only be used when rendering with {@link WebGLRenderer}. The
		 * recommended approach when customizing materials is to use `WebGPURenderer` with the new
		 * Node Material system and [TSL]{@link https://github.com/mrdoob/three.js/wiki/Three.js-Shading-Language}.
		 *
		 * @param {{vertexShader:string,fragmentShader:string,uniforms:Object}} shaderobject - The object holds the uniforms and the vertex and fragment shader source.
		 * @param {WebGLRenderer} renderer - A reference to the renderer.
		 */ onBeforeCompile() {}
	    /**
		 * In case {@link Material#onBeforeCompile} is used, this callback can be used to identify
		 * values of settings used in `onBeforeCompile()`, so three.js can reuse a cached
		 * shader or recompile the shader for this material as needed.
		 *
		 * This method can only be used when rendering with {@link WebGLRenderer}.
		 *
		 * @return {string} The custom program cache key.
		 */ customProgramCacheKey() {
	        return this.onBeforeCompile.toString();
	    }
	    setValues(values) {
	        if (values === undefined) return;
	        for(const key in values){
	            const newValue = values[key];
	            if (newValue === undefined) {
	                console.warn(`THREE.Material: parameter '${key}' has value of undefined.`);
	                continue;
	            }
	            const currentValue = this[key];
	            if (currentValue === undefined) {
	                console.warn(`THREE.Material: '${key}' is not a property of THREE.${this.type}.`);
	                continue;
	            }
	            if (currentValue && currentValue.isColor) {
	                currentValue.set(newValue);
	            } else if (currentValue && currentValue.isVector3 && newValue && newValue.isVector3) {
	                currentValue.copy(newValue);
	            } else {
	                this[key] = newValue;
	            }
	        }
	    }
	    /**
		 * Serializes the material into JSON.
		 *
		 * @param {?(Object|string)} meta - An optional value holding meta information about the serialization.
		 * @return {Object} A JSON object representing the serialized material.
		 * @see {@link ObjectLoader#parse}
		 */ toJSON(meta) {
	        const isRootObject = meta === undefined || typeof meta === 'string';
	        if (isRootObject) {
	            meta = {
	                textures: {},
	                images: {}
	            };
	        }
	        const data = {
	            metadata: {
	                version: 4.6,
	                type: 'Material',
	                generator: 'Material.toJSON'
	            }
	        };
	        // standard Material serialization
	        data.uuid = this.uuid;
	        data.type = this.type;
	        if (this.name !== '') data.name = this.name;
	        if (this.color && this.color.isColor) data.color = this.color.getHex();
	        if (this.roughness !== undefined) data.roughness = this.roughness;
	        if (this.metalness !== undefined) data.metalness = this.metalness;
	        if (this.sheen !== undefined) data.sheen = this.sheen;
	        if (this.sheenColor && this.sheenColor.isColor) data.sheenColor = this.sheenColor.getHex();
	        if (this.sheenRoughness !== undefined) data.sheenRoughness = this.sheenRoughness;
	        if (this.emissive && this.emissive.isColor) data.emissive = this.emissive.getHex();
	        if (this.emissiveIntensity !== undefined && this.emissiveIntensity !== 1) data.emissiveIntensity = this.emissiveIntensity;
	        if (this.specular && this.specular.isColor) data.specular = this.specular.getHex();
	        if (this.specularIntensity !== undefined) data.specularIntensity = this.specularIntensity;
	        if (this.specularColor && this.specularColor.isColor) data.specularColor = this.specularColor.getHex();
	        if (this.shininess !== undefined) data.shininess = this.shininess;
	        if (this.clearcoat !== undefined) data.clearcoat = this.clearcoat;
	        if (this.clearcoatRoughness !== undefined) data.clearcoatRoughness = this.clearcoatRoughness;
	        if (this.clearcoatMap && this.clearcoatMap.isTexture) {
	            data.clearcoatMap = this.clearcoatMap.toJSON(meta).uuid;
	        }
	        if (this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture) {
	            data.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON(meta).uuid;
	        }
	        if (this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture) {
	            data.clearcoatNormalMap = this.clearcoatNormalMap.toJSON(meta).uuid;
	            data.clearcoatNormalScale = this.clearcoatNormalScale.toArray();
	        }
	        if (this.dispersion !== undefined) data.dispersion = this.dispersion;
	        if (this.iridescence !== undefined) data.iridescence = this.iridescence;
	        if (this.iridescenceIOR !== undefined) data.iridescenceIOR = this.iridescenceIOR;
	        if (this.iridescenceThicknessRange !== undefined) data.iridescenceThicknessRange = this.iridescenceThicknessRange;
	        if (this.iridescenceMap && this.iridescenceMap.isTexture) {
	            data.iridescenceMap = this.iridescenceMap.toJSON(meta).uuid;
	        }
	        if (this.iridescenceThicknessMap && this.iridescenceThicknessMap.isTexture) {
	            data.iridescenceThicknessMap = this.iridescenceThicknessMap.toJSON(meta).uuid;
	        }
	        if (this.anisotropy !== undefined) data.anisotropy = this.anisotropy;
	        if (this.anisotropyRotation !== undefined) data.anisotropyRotation = this.anisotropyRotation;
	        if (this.anisotropyMap && this.anisotropyMap.isTexture) {
	            data.anisotropyMap = this.anisotropyMap.toJSON(meta).uuid;
	        }
	        if (this.map && this.map.isTexture) data.map = this.map.toJSON(meta).uuid;
	        if (this.matcap && this.matcap.isTexture) data.matcap = this.matcap.toJSON(meta).uuid;
	        if (this.alphaMap && this.alphaMap.isTexture) data.alphaMap = this.alphaMap.toJSON(meta).uuid;
	        if (this.lightMap && this.lightMap.isTexture) {
	            data.lightMap = this.lightMap.toJSON(meta).uuid;
	            data.lightMapIntensity = this.lightMapIntensity;
	        }
	        if (this.aoMap && this.aoMap.isTexture) {
	            data.aoMap = this.aoMap.toJSON(meta).uuid;
	            data.aoMapIntensity = this.aoMapIntensity;
	        }
	        if (this.bumpMap && this.bumpMap.isTexture) {
	            data.bumpMap = this.bumpMap.toJSON(meta).uuid;
	            data.bumpScale = this.bumpScale;
	        }
	        if (this.normalMap && this.normalMap.isTexture) {
	            data.normalMap = this.normalMap.toJSON(meta).uuid;
	            data.normalMapType = this.normalMapType;
	            data.normalScale = this.normalScale.toArray();
	        }
	        if (this.displacementMap && this.displacementMap.isTexture) {
	            data.displacementMap = this.displacementMap.toJSON(meta).uuid;
	            data.displacementScale = this.displacementScale;
	            data.displacementBias = this.displacementBias;
	        }
	        if (this.roughnessMap && this.roughnessMap.isTexture) data.roughnessMap = this.roughnessMap.toJSON(meta).uuid;
	        if (this.metalnessMap && this.metalnessMap.isTexture) data.metalnessMap = this.metalnessMap.toJSON(meta).uuid;
	        if (this.emissiveMap && this.emissiveMap.isTexture) data.emissiveMap = this.emissiveMap.toJSON(meta).uuid;
	        if (this.specularMap && this.specularMap.isTexture) data.specularMap = this.specularMap.toJSON(meta).uuid;
	        if (this.specularIntensityMap && this.specularIntensityMap.isTexture) data.specularIntensityMap = this.specularIntensityMap.toJSON(meta).uuid;
	        if (this.specularColorMap && this.specularColorMap.isTexture) data.specularColorMap = this.specularColorMap.toJSON(meta).uuid;
	        if (this.envMap && this.envMap.isTexture) {
	            data.envMap = this.envMap.toJSON(meta).uuid;
	            if (this.combine !== undefined) data.combine = this.combine;
	        }
	        if (this.envMapRotation !== undefined) data.envMapRotation = this.envMapRotation.toArray();
	        if (this.envMapIntensity !== undefined) data.envMapIntensity = this.envMapIntensity;
	        if (this.reflectivity !== undefined) data.reflectivity = this.reflectivity;
	        if (this.refractionRatio !== undefined) data.refractionRatio = this.refractionRatio;
	        if (this.gradientMap && this.gradientMap.isTexture) {
	            data.gradientMap = this.gradientMap.toJSON(meta).uuid;
	        }
	        if (this.transmission !== undefined) data.transmission = this.transmission;
	        if (this.transmissionMap && this.transmissionMap.isTexture) data.transmissionMap = this.transmissionMap.toJSON(meta).uuid;
	        if (this.thickness !== undefined) data.thickness = this.thickness;
	        if (this.thicknessMap && this.thicknessMap.isTexture) data.thicknessMap = this.thicknessMap.toJSON(meta).uuid;
	        if (this.attenuationDistance !== undefined && this.attenuationDistance !== Infinity) data.attenuationDistance = this.attenuationDistance;
	        if (this.attenuationColor !== undefined) data.attenuationColor = this.attenuationColor.getHex();
	        if (this.size !== undefined) data.size = this.size;
	        if (this.shadowSide !== null) data.shadowSide = this.shadowSide;
	        if (this.sizeAttenuation !== undefined) data.sizeAttenuation = this.sizeAttenuation;
	        if (this.blending !== NormalBlending) data.blending = this.blending;
	        if (this.side !== FrontSide) data.side = this.side;
	        if (this.vertexColors === true) data.vertexColors = true;
	        if (this.opacity < 1) data.opacity = this.opacity;
	        if (this.transparent === true) data.transparent = true;
	        if (this.blendSrc !== SrcAlphaFactor) data.blendSrc = this.blendSrc;
	        if (this.blendDst !== OneMinusSrcAlphaFactor) data.blendDst = this.blendDst;
	        if (this.blendEquation !== AddEquation) data.blendEquation = this.blendEquation;
	        if (this.blendSrcAlpha !== null) data.blendSrcAlpha = this.blendSrcAlpha;
	        if (this.blendDstAlpha !== null) data.blendDstAlpha = this.blendDstAlpha;
	        if (this.blendEquationAlpha !== null) data.blendEquationAlpha = this.blendEquationAlpha;
	        if (this.blendColor && this.blendColor.isColor) data.blendColor = this.blendColor.getHex();
	        if (this.blendAlpha !== 0) data.blendAlpha = this.blendAlpha;
	        if (this.depthFunc !== LessEqualDepth) data.depthFunc = this.depthFunc;
	        if (this.depthTest === false) data.depthTest = this.depthTest;
	        if (this.depthWrite === false) data.depthWrite = this.depthWrite;
	        if (this.colorWrite === false) data.colorWrite = this.colorWrite;
	        if (this.stencilWriteMask !== 0xff) data.stencilWriteMask = this.stencilWriteMask;
	        if (this.stencilFunc !== AlwaysStencilFunc) data.stencilFunc = this.stencilFunc;
	        if (this.stencilRef !== 0) data.stencilRef = this.stencilRef;
	        if (this.stencilFuncMask !== 0xff) data.stencilFuncMask = this.stencilFuncMask;
	        if (this.stencilFail !== KeepStencilOp) data.stencilFail = this.stencilFail;
	        if (this.stencilZFail !== KeepStencilOp) data.stencilZFail = this.stencilZFail;
	        if (this.stencilZPass !== KeepStencilOp) data.stencilZPass = this.stencilZPass;
	        if (this.stencilWrite === true) data.stencilWrite = this.stencilWrite;
	        // rotation (SpriteMaterial)
	        if (this.rotation !== undefined && this.rotation !== 0) data.rotation = this.rotation;
	        if (this.polygonOffset === true) data.polygonOffset = true;
	        if (this.polygonOffsetFactor !== 0) data.polygonOffsetFactor = this.polygonOffsetFactor;
	        if (this.polygonOffsetUnits !== 0) data.polygonOffsetUnits = this.polygonOffsetUnits;
	        if (this.linewidth !== undefined && this.linewidth !== 1) data.linewidth = this.linewidth;
	        if (this.dashSize !== undefined) data.dashSize = this.dashSize;
	        if (this.gapSize !== undefined) data.gapSize = this.gapSize;
	        if (this.scale !== undefined) data.scale = this.scale;
	        if (this.dithering === true) data.dithering = true;
	        if (this.alphaTest > 0) data.alphaTest = this.alphaTest;
	        if (this.alphaHash === true) data.alphaHash = true;
	        if (this.alphaToCoverage === true) data.alphaToCoverage = true;
	        if (this.premultipliedAlpha === true) data.premultipliedAlpha = true;
	        if (this.forceSinglePass === true) data.forceSinglePass = true;
	        if (this.wireframe === true) data.wireframe = true;
	        if (this.wireframeLinewidth > 1) data.wireframeLinewidth = this.wireframeLinewidth;
	        if (this.wireframeLinecap !== 'round') data.wireframeLinecap = this.wireframeLinecap;
	        if (this.wireframeLinejoin !== 'round') data.wireframeLinejoin = this.wireframeLinejoin;
	        if (this.flatShading === true) data.flatShading = true;
	        if (this.visible === false) data.visible = false;
	        if (this.toneMapped === false) data.toneMapped = false;
	        if (this.fog === false) data.fog = false;
	        if (Object.keys(this.userData).length > 0) data.userData = this.userData;
	        // TODO: Copied from Object3D.toJSON
	        function extractFromCache(cache) {
	            const values = [];
	            for(const key in cache){
	                const data = cache[key];
	                delete data.metadata;
	                values.push(data);
	            }
	            return values;
	        }
	        if (isRootObject) {
	            const textures = extractFromCache(meta.textures);
	            const images = extractFromCache(meta.images);
	            if (textures.length > 0) data.textures = textures;
	            if (images.length > 0) data.images = images;
	        }
	        return data;
	    }
	    /**
		 * Returns a new material with copied values from this instance.
		 *
		 * @return {Material} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Copies the values of the given material to this instance.
		 *
		 * @param {Material} source - The material to copy.
		 * @return {Material} A reference to this instance.
		 */ copy(source) {
	        this.name = source.name;
	        this.blending = source.blending;
	        this.side = source.side;
	        this.vertexColors = source.vertexColors;
	        this.opacity = source.opacity;
	        this.transparent = source.transparent;
	        this.blendSrc = source.blendSrc;
	        this.blendDst = source.blendDst;
	        this.blendEquation = source.blendEquation;
	        this.blendSrcAlpha = source.blendSrcAlpha;
	        this.blendDstAlpha = source.blendDstAlpha;
	        this.blendEquationAlpha = source.blendEquationAlpha;
	        this.blendColor.copy(source.blendColor);
	        this.blendAlpha = source.blendAlpha;
	        this.depthFunc = source.depthFunc;
	        this.depthTest = source.depthTest;
	        this.depthWrite = source.depthWrite;
	        this.stencilWriteMask = source.stencilWriteMask;
	        this.stencilFunc = source.stencilFunc;
	        this.stencilRef = source.stencilRef;
	        this.stencilFuncMask = source.stencilFuncMask;
	        this.stencilFail = source.stencilFail;
	        this.stencilZFail = source.stencilZFail;
	        this.stencilZPass = source.stencilZPass;
	        this.stencilWrite = source.stencilWrite;
	        const srcPlanes = source.clippingPlanes;
	        let dstPlanes = null;
	        if (srcPlanes !== null) {
	            const n = srcPlanes.length;
	            dstPlanes = new Array(n);
	            for(let i = 0; i !== n; ++i){
	                dstPlanes[i] = srcPlanes[i].clone();
	            }
	        }
	        this.clippingPlanes = dstPlanes;
	        this.clipIntersection = source.clipIntersection;
	        this.clipShadows = source.clipShadows;
	        this.shadowSide = source.shadowSide;
	        this.colorWrite = source.colorWrite;
	        this.precision = source.precision;
	        this.polygonOffset = source.polygonOffset;
	        this.polygonOffsetFactor = source.polygonOffsetFactor;
	        this.polygonOffsetUnits = source.polygonOffsetUnits;
	        this.dithering = source.dithering;
	        this.alphaTest = source.alphaTest;
	        this.alphaHash = source.alphaHash;
	        this.alphaToCoverage = source.alphaToCoverage;
	        this.premultipliedAlpha = source.premultipliedAlpha;
	        this.forceSinglePass = source.forceSinglePass;
	        this.visible = source.visible;
	        this.toneMapped = source.toneMapped;
	        this.userData = JSON.parse(JSON.stringify(source.userData));
	        return this;
	    }
	    /**
		 * Frees the GPU-related resources allocated by this instance. Call this
		 * method whenever this instance is no longer used in your app.
		 *
		 * @fires Material#dispose
		 */ dispose() {
	        /**
			 * Fires when the material has been disposed of.
			 *
			 * @event Material#dispose
			 * @type {Object}
			 */ this.dispatchEvent({
	            type: 'dispose'
	        });
	    }
	    /**
		 * Setting this property to `true` indicates the engine the material
		 * needs to be recompiled.
		 *
		 * @type {boolean}
		 * @default false
		 * @param {boolean} value
		 */ set needsUpdate(value) {
	        if (value === true) this.version++;
	    }
	    onBuild() {
	        console.warn('Material: onBuild() has been removed.'); // @deprecated, r166
	    }
	    /**
		 * Constructs a new material.
		 */ constructor(){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isMaterial = true;
	        /**
			 * The ID of the material.
			 *
			 * @name Material#id
			 * @type {number}
			 * @readonly
			 */ Object.defineProperty(this, 'id', {
	            value: _materialId++
	        });
	        /**
			 * The UUID of the material.
			 *
			 * @type {string}
			 * @readonly
			 */ this.uuid = generateUUID();
	        /**
			 * The name of the material.
			 *
			 * @type {string}
			 */ this.name = '';
	        /**
			 * The type property is used for detecting the object type
			 * in context of serialization/deserialization.
			 *
			 * @type {string}
			 * @readonly
			 */ this.type = 'Material';
	        /**
			 * Defines the blending type of the material.
			 *
			 * It must be set to `CustomBlending` if custom blending properties like
			 * {@link Material#blendSrc}, {@link Material#blendDst} or {@link Material#blendEquation}
			 * should have any effect.
			 *
			 * @type {(NoBlending|NormalBlending|AdditiveBlending|SubtractiveBlending|MultiplyBlending|CustomBlending)}
			 * @default NormalBlending
			 */ this.blending = NormalBlending;
	        /**
			 * Defines which side of faces will be rendered - front, back or both.
			 *
			 * @type {(FrontSide|BackSide|DoubleSide)}
			 * @default FrontSide
			 */ this.side = FrontSide;
	        /**
			 * If set to `true`, vertex colors should be used.
			 *
			 * The engine supports RGB and RGBA vertex colors depending on whether a three (RGB) or
			 * four (RGBA) component color buffer attribute is used.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.vertexColors = false;
	        /**
			 * Defines how transparent the material is.
			 * A value of `0.0` indicates fully transparent, `1.0` is fully opaque.
			 *
			 * If the {@link Material#transparent} is not set to `true`,
			 * the material will remain fully opaque and this value will only affect its color.
			 *
			 * @type {number}
			 * @default 1
			 */ this.opacity = 1;
	        /**
			 * Defines whether this material is transparent. This has an effect on
			 * rendering as transparent objects need special treatment and are rendered
			 * after non-transparent objects.
			 *
			 * When set to true, the extent to which the material is transparent is
			 * controlled by {@link Material#opacity}.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.transparent = false;
	        /**
			 * Enables alpha hashed transparency, an alternative to {@link Material#transparent} or
			 * {@link Material#alphaTest}. The material will not be rendered if opacity is lower than
			 * a random threshold. Randomization introduces some grain or noise, but approximates alpha
			 * blending without the associated problems of sorting. Using TAA can reduce the resulting noise.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.alphaHash = false;
	        /**
			 * Defines the blending source factor.
			 *
			 * @type {(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
			 * @default SrcAlphaFactor
			 */ this.blendSrc = SrcAlphaFactor;
	        /**
			 * Defines the blending destination factor.
			 *
			 * @type {(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
			 * @default OneMinusSrcAlphaFactor
			 */ this.blendDst = OneMinusSrcAlphaFactor;
	        /**
			 * Defines the blending equation.
			 *
			 * @type {(AddEquation|SubtractEquation|ReverseSubtractEquation|MinEquation|MaxEquation)}
			 * @default OneMinusSrcAlphaFactor
			 */ this.blendEquation = AddEquation;
	        /**
			 * Defines the blending source alpha factor.
			 *
			 * @type {?(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
			 * @default null
			 */ this.blendSrcAlpha = null;
	        /**
			 * Defines the blending destination alpha factor.
			 *
			 * @type {?(ZeroFactor|OneFactor|SrcColorFactor|OneMinusSrcColorFactor|SrcAlphaFactor|OneMinusSrcAlphaFactor|DstAlphaFactor|OneMinusDstAlphaFactor|DstColorFactor|OneMinusDstColorFactor|SrcAlphaSaturateFactor|ConstantColorFactor|OneMinusConstantColorFactor|ConstantAlphaFactor|OneMinusConstantAlphaFactor)}
			 * @default null
			 */ this.blendDstAlpha = null;
	        /**
			 * Defines the blending equation of the alpha channel.
			 *
			 * @type {(AddEquation|SubtractEquation|ReverseSubtractEquation|MinEquation|MaxEquation)}
			 * @default OneMinusSrcAlphaFactor
			 */ this.blendEquationAlpha = null;
	        /**
			 * Represents the RGB values of the constant blend color.
			 *
			 * This property has only an effect when using custom blending with `ConstantColor` or `OneMinusConstantColor`.
			 *
			 * @type {Color}
			 * @default (0,0,0)
			 */ this.blendColor = new Color(0, 0, 0);
	        /**
			 * Represents the alpha value of the constant blend color.
			 *
			 * This property has only an effect when using custom blending with `ConstantAlpha` or `OneMinusConstantAlpha`.
			 *
			 * @type {number}
			 * @default 0
			 */ this.blendAlpha = 0;
	        /**
			 * Defines the depth function.
			 *
			 * @type {(NeverDepth|AlwaysDepth|LessDepth|LessEqualDepth|EqualDepth|GreaterEqualDepth|GreaterDepth|NotEqualDepth)}
			 * @default LessEqualDepth
			 */ this.depthFunc = LessEqualDepth;
	        /**
			 * Whether to have depth test enabled when rendering this material.
			 * When the depth test is disabled, the depth write will also be implicitly disabled.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.depthTest = true;
	        /**
			 * Whether rendering this material has any effect on the depth buffer.
			 *
			 * When drawing 2D overlays it can be useful to disable the depth writing in
			 * order to layer several things together without creating z-index artifacts.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.depthWrite = true;
	        /**
			 * The bit mask to use when writing to the stencil buffer.
			 *
			 * @type {number}
			 * @default 0xff
			 */ this.stencilWriteMask = 0xff;
	        /**
			 * The stencil comparison function to use.
			 *
			 * @type {NeverStencilFunc|LessStencilFunc|EqualStencilFunc|LessEqualStencilFunc|GreaterStencilFunc|NotEqualStencilFunc|GreaterEqualStencilFunc|AlwaysStencilFunc}
			 * @default AlwaysStencilFunc
			 */ this.stencilFunc = AlwaysStencilFunc;
	        /**
			 * The value to use when performing stencil comparisons or stencil operations.
			 *
			 * @type {number}
			 * @default 0
			 */ this.stencilRef = 0;
	        /**
			 * The bit mask to use when comparing against the stencil buffer.
			 *
			 * @type {number}
			 * @default 0xff
			 */ this.stencilFuncMask = 0xff;
	        /**
			 * Which stencil operation to perform when the comparison function returns `false`.
			 *
			 * @type {ZeroStencilOp|KeepStencilOp|ReplaceStencilOp|IncrementStencilOp|DecrementStencilOp|IncrementWrapStencilOp|DecrementWrapStencilOp|InvertStencilOp}
			 * @default KeepStencilOp
			 */ this.stencilFail = KeepStencilOp;
	        /**
			 * Which stencil operation to perform when the comparison function returns
			 * `true` but the depth test fails.
			 *
			 * @type {ZeroStencilOp|KeepStencilOp|ReplaceStencilOp|IncrementStencilOp|DecrementStencilOp|IncrementWrapStencilOp|DecrementWrapStencilOp|InvertStencilOp}
			 * @default KeepStencilOp
			 */ this.stencilZFail = KeepStencilOp;
	        /**
			 * Which stencil operation to perform when the comparison function returns
			 * `true` and the depth test passes.
			 *
			 * @type {ZeroStencilOp|KeepStencilOp|ReplaceStencilOp|IncrementStencilOp|DecrementStencilOp|IncrementWrapStencilOp|DecrementWrapStencilOp|InvertStencilOp}
			 * @default KeepStencilOp
			 */ this.stencilZPass = KeepStencilOp;
	        /**
			 * Whether stencil operations are performed against the stencil buffer. In
			 * order to perform writes or comparisons against the stencil buffer this
			 * value must be `true`.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.stencilWrite = false;
	        /**
			 * User-defined clipping planes specified as THREE.Plane objects in world
			 * space. These planes apply to the objects this material is attached to.
			 * Points in space whose signed distance to the plane is negative are clipped
			 * (not rendered). This requires {@link WebGLRenderer#localClippingEnabled} to
			 * be `true`.
			 *
			 * @type {?Array<Plane>}
			 * @default null
			 */ this.clippingPlanes = null;
	        /**
			 * Changes the behavior of clipping planes so that only their intersection is
			 * clipped, rather than their union.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.clipIntersection = false;
	        /**
			 * Defines whether to clip shadows according to the clipping planes specified
			 * on this material.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.clipShadows = false;
	        /**
			 * Defines which side of faces cast shadows. If `null`, the side casting shadows
			 * is determined as follows:
			 *
			 * - When {@link Material#side} is set to `FrontSide`, the back side cast shadows.
			 * - When {@link Material#side} is set to `BackSide`, the front side cast shadows.
			 * - When {@link Material#side} is set to `DoubleSide`, both sides cast shadows.
			 *
			 * @type {?(FrontSide|BackSide|DoubleSide)}
			 * @default null
			 */ this.shadowSide = null;
	        /**
			 * Whether to render the material's color.
			 *
			 * This can be used in conjunction with {@link Object3D#renderOder} to create invisible
			 * objects that occlude other objects.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.colorWrite = true;
	        /**
			 * Override the renderer's default precision for this material.
			 *
			 * @type {?('highp'|'mediump'|'lowp')}
			 * @default null
			 */ this.precision = null;
	        /**
			 * Whether to use polygon offset or not. When enabled, each fragment's depth value will
			 * be offset after it is interpolated from the depth values of the appropriate vertices.
			 * The offset is added before the depth test is performed and before the value is written
			 * into the depth buffer.
			 *
			 * Can be useful for rendering hidden-line images, for applying decals to surfaces, and for
			 * rendering solids with highlighted edges.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.polygonOffset = false;
	        /**
			 * Specifies a scale factor that is used to create a variable depth offset for each polygon.
			 *
			 * @type {number}
			 * @default 0
			 */ this.polygonOffsetFactor = 0;
	        /**
			 * Is multiplied by an implementation-specific value to create a constant depth offset.
			 *
			 * @type {number}
			 * @default 0
			 */ this.polygonOffsetUnits = 0;
	        /**
			 * Whether to apply dithering to the color to remove the appearance of banding.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.dithering = false;
	        /**
			 * Whether alpha to coverage should be enabled or not. Can only be used with MSAA-enabled contexts
			 * (meaning when the renderer was created with *antialias* parameter set to `true`). Enabling this
			 * will smooth aliasing on clip plane edges and alphaTest-clipped edges.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.alphaToCoverage = false;
	        /**
			 * Whether to premultiply the alpha (transparency) value.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.premultipliedAlpha = false;
	        /**
			 * Whether double-sided, transparent objects should be rendered with a single pass or not.
			 *
			 * The engine renders double-sided, transparent objects with two draw calls (back faces first,
			 * then front faces) to mitigate transparency artifacts. There are scenarios however where this
			 * approach produces no quality gains but still doubles draw calls e.g. when rendering flat
			 * vegetation like grass sprites. In these cases, set the `forceSinglePass` flag to `true` to
			 * disable the two pass rendering to avoid performance issues.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.forceSinglePass = false;
	        /**
			 * Defines whether 3D objects using this material are visible.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.visible = true;
	        /**
			 * Defines whether this material is tone mapped according to the renderer's tone mapping setting.
			 *
			 * It is ignored when rendering to a render target or using post processing or when using
			 * `WebGPURenderer`. In all these cases, all materials are honored by tone mapping.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.toneMapped = true;
	        /**
			 * An object that can be used to store custom data about the Material. It
			 * should not hold references to functions as these will not be cloned.
			 *
			 * @type {Object}
			 */ this.userData = {};
	        /**
			 * This starts at `0` and counts how many times {@link Material#needsUpdate} is set to `true`.
			 *
			 * @type {number}
			 * @readonly
			 * @default 0
			 */ this.version = 0;
	        this._alphaTest = 0;
	    }
	};
	class MeshBasicMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.color.copy(source.color);
	        this.map = source.map;
	        this.lightMap = source.lightMap;
	        this.lightMapIntensity = source.lightMapIntensity;
	        this.aoMap = source.aoMap;
	        this.aoMapIntensity = source.aoMapIntensity;
	        this.specularMap = source.specularMap;
	        this.alphaMap = source.alphaMap;
	        this.envMap = source.envMap;
	        this.envMapRotation.copy(source.envMapRotation);
	        this.combine = source.combine;
	        this.reflectivity = source.reflectivity;
	        this.refractionRatio = source.refractionRatio;
	        this.wireframe = source.wireframe;
	        this.wireframeLinewidth = source.wireframeLinewidth;
	        this.wireframeLinecap = source.wireframeLinecap;
	        this.wireframeLinejoin = source.wireframeLinejoin;
	        this.fog = source.fog;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isMeshBasicMaterial = true;
	        this.type = 'MeshBasicMaterial';
	        this.color = new Color(0xffffff); // emissive
	        this.map = null;
	        this.lightMap = null;
	        this.lightMapIntensity = 1.0;
	        this.aoMap = null;
	        this.aoMapIntensity = 1.0;
	        this.specularMap = null;
	        this.alphaMap = null;
	        this.envMap = null;
	        this.envMapRotation = new Euler();
	        this.combine = MultiplyOperation;
	        this.reflectivity = 1;
	        this.refractionRatio = 0.98;
	        this.wireframe = false;
	        this.wireframeLinewidth = 1;
	        this.wireframeLinecap = 'round';
	        this.wireframeLinejoin = 'round';
	        this.fog = true;
	        this.setValues(parameters);
	    }
	}
	// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
	const _tables = /*@__PURE__*/ _generateTables();
	function _generateTables() {
	    // float32 to float16 helpers
	    const buffer = new ArrayBuffer(4);
	    const floatView = new Float32Array(buffer);
	    const uint32View = new Uint32Array(buffer);
	    const baseTable = new Uint32Array(512);
	    const shiftTable = new Uint32Array(512);
	    for(let i = 0; i < 256; ++i){
	        const e = i - 127;
	        // very small number (0, -0)
	        if (e < -27) {
	            baseTable[i] = 0x0000;
	            baseTable[i | 0x100] = 0x8000;
	            shiftTable[i] = 24;
	            shiftTable[i | 0x100] = 24;
	        // small number (denorm)
	        } else if (e < -14) {
	            baseTable[i] = 0x0400 >> -e - 14;
	            baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
	            shiftTable[i] = -e - 1;
	            shiftTable[i | 0x100] = -e - 1;
	        // normal number
	        } else if (e <= 15) {
	            baseTable[i] = e + 15 << 10;
	            baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
	            shiftTable[i] = 13;
	            shiftTable[i | 0x100] = 13;
	        // large number (Infinity, -Infinity)
	        } else if (e < 128) {
	            baseTable[i] = 0x7c00;
	            baseTable[i | 0x100] = 0xfc00;
	            shiftTable[i] = 24;
	            shiftTable[i | 0x100] = 24;
	        // stay (NaN, Infinity, -Infinity)
	        } else {
	            baseTable[i] = 0x7c00;
	            baseTable[i | 0x100] = 0xfc00;
	            shiftTable[i] = 13;
	            shiftTable[i | 0x100] = 13;
	        }
	    }
	    // float16 to float32 helpers
	    const mantissaTable = new Uint32Array(2048);
	    const exponentTable = new Uint32Array(64);
	    const offsetTable = new Uint32Array(64);
	    for(let i = 1; i < 1024; ++i){
	        let m = i << 13; // zero pad mantissa bits
	        let e = 0; // zero exponent
	        // normalized
	        while((m & 0x00800000) === 0){
	            m <<= 1;
	            e -= 0x00800000; // decrement exponent
	        }
	        m &= -8388609; // clear leading 1 bit
	        e += 0x38800000; // adjust bias
	        mantissaTable[i] = m | e;
	    }
	    for(let i = 1024; i < 2048; ++i){
	        mantissaTable[i] = 0x38000000 + (i - 1024 << 13);
	    }
	    for(let i = 1; i < 31; ++i){
	        exponentTable[i] = i << 23;
	    }
	    exponentTable[31] = 0x47800000;
	    exponentTable[32] = 0x80000000;
	    for(let i = 33; i < 63; ++i){
	        exponentTable[i] = 0x80000000 + (i - 32 << 23);
	    }
	    exponentTable[63] = 0xc7800000;
	    for(let i = 1; i < 64; ++i){
	        if (i !== 32) {
	            offsetTable[i] = 1024;
	        }
	    }
	    return {
	        floatView: floatView,
	        uint32View: uint32View,
	        baseTable: baseTable,
	        shiftTable: shiftTable,
	        mantissaTable: mantissaTable,
	        exponentTable: exponentTable,
	        offsetTable: offsetTable
	    };
	}
	/**
	 * Returns a half precision floating point value (FP16) from the given single
	 * precision floating point value (FP32).
	 *
	 * @param {number} val - A single precision floating point value.
	 * @return {number} The FP16 value.
	 */ function toHalfFloat(val) {
	    if (Math.abs(val) > 65504) console.warn('THREE.DataUtils.toHalfFloat(): Value out of range.');
	    val = clamp$1(val, -65504, 65504);
	    _tables.floatView[0] = val;
	    const f = _tables.uint32View[0];
	    const e = f >> 23 & 0x1ff;
	    return _tables.baseTable[e] + ((f & 0x007fffff) >> _tables.shiftTable[e]);
	}
	/**
	 * Returns a single precision floating point value (FP32) from the given half
	 * precision floating point value (FP16).
	 *
	 * @param {number} val - A half precision floating point value.
	 * @return {number} The FP32 value.
	 */ function fromHalfFloat(val) {
	    const m = val >> 10;
	    _tables.uint32View[0] = _tables.mantissaTable[_tables.offsetTable[m] + (val & 0x3ff)] + _tables.exponentTable[m];
	    return _tables.floatView[0];
	}
	/**
	 * A class containing utility functions for data.
	 *
	 * @hideconstructor
	 */ class DataUtils {
	    /**
		 * Returns a half precision floating point value (FP16) from the given single
		 * precision floating point value (FP32).
		 *
		 * @param {number} val - A single precision floating point value.
		 * @return {number} The FP16 value.
		 */ static toHalfFloat(val) {
	        return toHalfFloat(val);
	    }
	    /**
		 * Returns a single precision floating point value (FP32) from the given half
		 * precision floating point value (FP16).
		 *
		 * @param {number} val - A half precision floating point value.
		 * @return {number} The FP32 value.
		 */ static fromHalfFloat(val) {
	        return fromHalfFloat(val);
	    }
	}
	const _vector$9 = /*@__PURE__*/ new Vector3();
	const _vector2$1 = /*@__PURE__*/ new Vector2();
	let _id$2 = 0;
	class BufferAttribute {
	    onUploadCallback() {}
	    set needsUpdate(value) {
	        if (value === true) this.version++;
	    }
	    setUsage(value) {
	        this.usage = value;
	        return this;
	    }
	    addUpdateRange(start, count) {
	        this.updateRanges.push({
	            start,
	            count
	        });
	    }
	    clearUpdateRanges() {
	        this.updateRanges.length = 0;
	    }
	    copy(source) {
	        this.name = source.name;
	        this.array = new source.array.constructor(source.array);
	        this.itemSize = source.itemSize;
	        this.count = source.count;
	        this.normalized = source.normalized;
	        this.usage = source.usage;
	        this.gpuType = source.gpuType;
	        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;
	    }
	    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.fromBufferAttribute(this, 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.fromBufferAttribute(this, 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.fromBufferAttribute(this, i);
	            _vector$9.transformDirection(m);
	            this.setXYZ(i, _vector$9.x, _vector$9.y, _vector$9.z);
	        }
	        return this;
	    }
	    set(value, offset = 0) {
	        // Matching BufferAttribute constructor, do not normalize the array.
	        this.array.set(value, offset);
	        return this;
	    }
	    getComponent(index, component) {
	        let value = this.array[index * this.itemSize + component];
	        if (this.normalized) value = denormalize(value, this.array);
	        return value;
	    }
	    setComponent(index, component, value) {
	        if (this.normalized) value = normalize(value, this.array);
	        this.array[index * this.itemSize + component] = value;
	        return this;
	    }
	    getX(index) {
	        let x = this.array[index * this.itemSize];
	        if (this.normalized) x = denormalize(x, this.array);
	        return x;
	    }
	    setX(index, x) {
	        if (this.normalized) x = normalize(x, this.array);
	        this.array[index * this.itemSize] = x;
	        return this;
	    }
	    getY(index) {
	        let y = this.array[index * this.itemSize + 1];
	        if (this.normalized) y = denormalize(y, this.array);
	        return y;
	    }
	    setY(index, y) {
	        if (this.normalized) y = normalize(y, this.array);
	        this.array[index * this.itemSize + 1] = y;
	        return this;
	    }
	    getZ(index) {
	        let z = this.array[index * this.itemSize + 2];
	        if (this.normalized) z = denormalize(z, this.array);
	        return z;
	    }
	    setZ(index, z) {
	        if (this.normalized) z = normalize(z, this.array);
	        this.array[index * this.itemSize + 2] = z;
	        return this;
	    }
	    getW(index) {
	        let w = this.array[index * this.itemSize + 3];
	        if (this.normalized) w = denormalize(w, this.array);
	        return w;
	    }
	    setW(index, w) {
	        if (this.normalized) w = normalize(w, this.array);
	        this.array[index * this.itemSize + 3] = w;
	        return this;
	    }
	    setXY(index, x, y) {
	        index *= this.itemSize;
	        if (this.normalized) {
	            x = normalize(x, this.array);
	            y = normalize(y, this.array);
	        }
	        this.array[index + 0] = x;
	        this.array[index + 1] = y;
	        return this;
	    }
	    setXYZ(index, x, y, z) {
	        index *= this.itemSize;
	        if (this.normalized) {
	            x = normalize(x, this.array);
	            y = normalize(y, this.array);
	            z = normalize(z, this.array);
	        }
	        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;
	        if (this.normalized) {
	            x = normalize(x, this.array);
	            y = normalize(y, this.array);
	            z = normalize(z, this.array);
	            w = normalize(w, this.array);
	        }
	        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.from(this.array),
	            normalized: this.normalized
	        };
	        if (this.name !== '') data.name = this.name;
	        if (this.usage !== StaticDrawUsage) data.usage = this.usage;
	        return data;
	    }
	    constructor(array, itemSize, normalized = false){
	        if (Array.isArray(array)) {
	            throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.');
	        }
	        this.isBufferAttribute = true;
	        Object.defineProperty(this, 'id', {
	            value: _id$2++
	        });
	        this.name = '';
	        this.array = array;
	        this.itemSize = itemSize;
	        this.count = array !== undefined ? array.length / itemSize : 0;
	        this.normalized = normalized;
	        this.usage = StaticDrawUsage;
	        this.updateRanges = [];
	        this.gpuType = FloatType;
	        this.version = 0;
	    }
	}
	class Uint16BufferAttribute extends BufferAttribute {
	    constructor(array, itemSize, normalized){
	        super(new Uint16Array(array), itemSize, normalized);
	    }
	}
	class Uint32BufferAttribute extends BufferAttribute {
	    constructor(array, itemSize, normalized){
	        super(new Uint32Array(array), itemSize, normalized);
	    }
	}
	class Float32BufferAttribute extends BufferAttribute {
	    constructor(array, itemSize, normalized){
	        super(new Float32Array(array), itemSize, normalized);
	    }
	}
	let _id$1 = 0;
	const _m1$3 = /*@__PURE__*/ new Matrix4();
	const _obj = /*@__PURE__*/ new Object3D();
	const _offset = /*@__PURE__*/ new Vector3();
	const _box$2 = /*@__PURE__*/ new Box3();
	const _boxMorphTargets = /*@__PURE__*/ new Box3();
	const _vector$8 = /*@__PURE__*/ new Vector3();
	class BufferGeometry extends EventDispatcher {
	    getIndex() {
	        return this.index;
	    }
	    setIndex(index) {
	        if (Array.isArray(index)) {
	            this.index = new (arrayNeedsUint32(index) ? Uint32BufferAttribute : Uint16BufferAttribute)(index, 1);
	        } else {
	            this.index = index;
	        }
	        return this;
	    }
	    setIndirect(indirect) {
	        this.indirect = indirect;
	        return this;
	    }
	    getIndirect() {
	        return this.indirect;
	    }
	    getAttribute(name) {
	        return this.attributes[name];
	    }
	    setAttribute(name, attribute) {
	        this.attributes[name] = attribute;
	        return this;
	    }
	    deleteAttribute(name) {
	        delete this.attributes[name];
	        return this;
	    }
	    hasAttribute(name) {
	        return this.attributes[name] !== undefined;
	    }
	    addGroup(start, count, materialIndex = 0) {
	        this.groups.push({
	            start: start,
	            count: count,
	            materialIndex: materialIndex
	        });
	    }
	    clearGroups() {
	        this.groups = [];
	    }
	    setDrawRange(start, count) {
	        this.drawRange.start = start;
	        this.drawRange.count = count;
	    }
	    applyMatrix4(matrix) {
	        const position = this.attributes.position;
	        if (position !== undefined) {
	            position.applyMatrix4(matrix);
	            position.needsUpdate = true;
	        }
	        const normal = this.attributes.normal;
	        if (normal !== undefined) {
	            const normalMatrix = new Matrix3().getNormalMatrix(matrix);
	            normal.applyNormalMatrix(normalMatrix);
	            normal.needsUpdate = true;
	        }
	        const tangent = this.attributes.tangent;
	        if (tangent !== undefined) {
	            tangent.transformDirection(matrix);
	            tangent.needsUpdate = true;
	        }
	        if (this.boundingBox !== null) {
	            this.computeBoundingBox();
	        }
	        if (this.boundingSphere !== null) {
	            this.computeBoundingSphere();
	        }
	        return this;
	    }
	    applyQuaternion(q) {
	        _m1$3.makeRotationFromQuaternion(q);
	        this.applyMatrix4(_m1$3);
	        return this;
	    }
	    rotateX(angle) {
	        // rotate geometry around world x-axis
	        _m1$3.makeRotationX(angle);
	        this.applyMatrix4(_m1$3);
	        return this;
	    }
	    rotateY(angle) {
	        // rotate geometry around world y-axis
	        _m1$3.makeRotationY(angle);
	        this.applyMatrix4(_m1$3);
	        return this;
	    }
	    rotateZ(angle) {
	        // rotate geometry around world z-axis
	        _m1$3.makeRotationZ(angle);
	        this.applyMatrix4(_m1$3);
	        return this;
	    }
	    translate(x, y, z) {
	        // translate geometry
	        _m1$3.makeTranslation(x, y, z);
	        this.applyMatrix4(_m1$3);
	        return this;
	    }
	    scale(x, y, z) {
	        // scale geometry
	        _m1$3.makeScale(x, y, z);
	        this.applyMatrix4(_m1$3);
	        return this;
	    }
	    lookAt(vector) {
	        _obj.lookAt(vector);
	        _obj.updateMatrix();
	        this.applyMatrix4(_obj.matrix);
	        return this;
	    }
	    center() {
	        this.computeBoundingBox();
	        this.boundingBox.getCenter(_offset).negate();
	        this.translate(_offset.x, _offset.y, _offset.z);
	        return this;
	    }
	    setFromPoints(points) {
	        const positionAttribute = this.getAttribute('position');
	        if (positionAttribute === undefined) {
	            const position = [];
	            for(let i = 0, l = points.length; i < l; i++){
	                const point = points[i];
	                position.push(point.x, point.y, point.z || 0);
	            }
	            this.setAttribute('position', new Float32BufferAttribute(position, 3));
	        } else {
	            const l = Math.min(points.length, positionAttribute.count); // make sure data do not exceed buffer size
	            for(let i = 0; i < l; i++){
	                const point = points[i];
	                positionAttribute.setXYZ(i, point.x, point.y, point.z || 0);
	            }
	            if (points.length > positionAttribute.count) {
	                console.warn('THREE.BufferGeometry: Buffer size too small for points data. Use .dispose() and create a new geometry.');
	            }
	            positionAttribute.needsUpdate = true;
	        }
	        return this;
	    }
	    computeBoundingBox() {
	        if (this.boundingBox === null) {
	            this.boundingBox = new Box3();
	        }
	        const position = this.attributes.position;
	        const morphAttributesPosition = this.morphAttributes.position;
	        if (position && position.isGLBufferAttribute) {
	            console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box.', this);
	            this.boundingBox.set(new Vector3(-Infinity, -Infinity, -Infinity), new Vector3(+Infinity, +Infinity, +Infinity));
	            return;
	        }
	        if (position !== undefined) {
	            this.boundingBox.setFromBufferAttribute(position);
	            // process morph attributes if present
	            if (morphAttributesPosition) {
	                for(let i = 0, il = morphAttributesPosition.length; i < il; i++){
	                    const morphAttribute = morphAttributesPosition[i];
	                    _box$2.setFromBufferAttribute(morphAttribute);
	                    if (this.morphTargetsRelative) {
	                        _vector$8.addVectors(this.boundingBox.min, _box$2.min);
	                        this.boundingBox.expandByPoint(_vector$8);
	                        _vector$8.addVectors(this.boundingBox.max, _box$2.max);
	                        this.boundingBox.expandByPoint(_vector$8);
	                    } else {
	                        this.boundingBox.expandByPoint(_box$2.min);
	                        this.boundingBox.expandByPoint(_box$2.max);
	                    }
	                }
	            }
	        } else {
	            this.boundingBox.makeEmpty();
	        }
	        if (isNaN(this.boundingBox.min.x) || isNaN(this.boundingBox.min.y) || isNaN(this.boundingBox.min.z)) {
	            console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this);
	        }
	    }
	    computeBoundingSphere() {
	        if (this.boundingSphere === null) {
	            this.boundingSphere = new Sphere();
	        }
	        const position = this.attributes.position;
	        const morphAttributesPosition = this.morphAttributes.position;
	        if (position && position.isGLBufferAttribute) {
	            console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere.', this);
	            this.boundingSphere.set(new Vector3(), Infinity);
	            return;
	        }
	        if (position) {
	            // first, find the center of the bounding sphere
	            const center = this.boundingSphere.center;
	            _box$2.setFromBufferAttribute(position);
	            // process morph attributes if present
	            if (morphAttributesPosition) {
	                for(let i = 0, il = morphAttributesPosition.length; i < il; i++){
	                    const morphAttribute = morphAttributesPosition[i];
	                    _boxMorphTargets.setFromBufferAttribute(morphAttribute);
	                    if (this.morphTargetsRelative) {
	                        _vector$8.addVectors(_box$2.min, _boxMorphTargets.min);
	                        _box$2.expandByPoint(_vector$8);
	                        _vector$8.addVectors(_box$2.max, _boxMorphTargets.max);
	                        _box$2.expandByPoint(_vector$8);
	                    } else {
	                        _box$2.expandByPoint(_boxMorphTargets.min);
	                        _box$2.expandByPoint(_boxMorphTargets.max);
	                    }
	                }
	            }
	            _box$2.getCenter(center);
	            // second, try to find a boundingSphere with a radius smaller than the
	            // boundingSphere of the boundingBox: sqrt(3) smaller in the best case
	            let maxRadiusSq = 0;
	            for(let i = 0, il = position.count; i < il; i++){
	                _vector$8.fromBufferAttribute(position, i);
	                maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8));
	            }
	            // process morph attributes if present
	            if (morphAttributesPosition) {
	                for(let i = 0, il = morphAttributesPosition.length; i < il; i++){
	                    const morphAttribute = morphAttributesPosition[i];
	                    const morphTargetsRelative = this.morphTargetsRelative;
	                    for(let j = 0, jl = morphAttribute.count; j < jl; j++){
	                        _vector$8.fromBufferAttribute(morphAttribute, j);
	                        if (morphTargetsRelative) {
	                            _offset.fromBufferAttribute(position, j);
	                            _vector$8.add(_offset);
	                        }
	                        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$8));
	                    }
	                }
	            }
	            this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
	            if (isNaN(this.boundingSphere.radius)) {
	                console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this);
	            }
	        }
	    }
	    computeTangents() {
	        const index = this.index;
	        const attributes = this.attributes;
	        // based on http://www.terathon.com/code/tangent.html
	        // (per vertex tangents)
	        if (index === null || attributes.position === undefined || attributes.normal === undefined || attributes.uv === undefined) {
	            console.error('THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)');
	            return;
	        }
	        const positionAttribute = attributes.position;
	        const normalAttribute = attributes.normal;
	        const uvAttribute = attributes.uv;
	        if (this.hasAttribute('tangent') === false) {
	            this.setAttribute('tangent', new BufferAttribute(new Float32Array(4 * positionAttribute.count), 4));
	        }
	        const tangentAttribute = this.getAttribute('tangent');
	        const tan1 = [], tan2 = [];
	        for(let i = 0; i < positionAttribute.count; i++){
	            tan1[i] = new Vector3();
	            tan2[i] = new Vector3();
	        }
	        const vA = new Vector3(), vB = new Vector3(), vC = new Vector3(), uvA = new Vector2(), uvB = new Vector2(), uvC = new Vector2(), sdir = new Vector3(), tdir = new Vector3();
	        function handleTriangle(a, b, c) {
	            vA.fromBufferAttribute(positionAttribute, a);
	            vB.fromBufferAttribute(positionAttribute, b);
	            vC.fromBufferAttribute(positionAttribute, c);
	            uvA.fromBufferAttribute(uvAttribute, a);
	            uvB.fromBufferAttribute(uvAttribute, b);
	            uvC.fromBufferAttribute(uvAttribute, c);
	            vB.sub(vA);
	            vC.sub(vA);
	            uvB.sub(uvA);
	            uvC.sub(uvA);
	            const r = 1.0 / (uvB.x * uvC.y - uvC.x * uvB.y);
	            // silently ignore degenerate uv triangles having coincident or colinear vertices
	            if (!isFinite(r)) return;
	            sdir.copy(vB).multiplyScalar(uvC.y).addScaledVector(vC, -uvB.y).multiplyScalar(r);
	            tdir.copy(vC).multiplyScalar(uvB.x).addScaledVector(vB, -uvC.x).multiplyScalar(r);
	            tan1[a].add(sdir);
	            tan1[b].add(sdir);
	            tan1[c].add(sdir);
	            tan2[a].add(tdir);
	            tan2[b].add(tdir);
	            tan2[c].add(tdir);
	        }
	        let groups = this.groups;
	        if (groups.length === 0) {
	            groups = [
	                {
	                    start: 0,
	                    count: index.count
	                }
	            ];
	        }
	        for(let i = 0, il = groups.length; i < il; ++i){
	            const group = groups[i];
	            const start = group.start;
	            const count = group.count;
	            for(let j = start, jl = start + count; j < jl; j += 3){
	                handleTriangle(index.getX(j + 0), index.getX(j + 1), index.getX(j + 2));
	            }
	        }
	        const tmp = new Vector3(), tmp2 = new Vector3();
	        const n = new Vector3(), n2 = new Vector3();
	        function handleVertex(v) {
	            n.fromBufferAttribute(normalAttribute, v);
	            n2.copy(n);
	            const t = tan1[v];
	            // Gram-Schmidt orthogonalize
	            tmp.copy(t);
	            tmp.sub(n.multiplyScalar(n.dot(t))).normalize();
	            // Calculate handedness
	            tmp2.crossVectors(n2, t);
	            const test = tmp2.dot(tan2[v]);
	            const w = test < 0.0 ? -1 : 1.0;
	            tangentAttribute.setXYZW(v, tmp.x, tmp.y, tmp.z, w);
	        }
	        for(let i = 0, il = groups.length; i < il; ++i){
	            const group = groups[i];
	            const start = group.start;
	            const count = group.count;
	            for(let j = start, jl = start + count; j < jl; j += 3){
	                handleVertex(index.getX(j + 0));
	                handleVertex(index.getX(j + 1));
	                handleVertex(index.getX(j + 2));
	            }
	        }
	    }
	    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);
	        }
	    }
	    toNonIndexed() {
	        function convertBufferAttribute(attribute, indices) {
	            const array = attribute.array;
	            const itemSize = attribute.itemSize;
	            const normalized = attribute.normalized;
	            const array2 = new array.constructor(indices.length * itemSize);
	            let index = 0, index2 = 0;
	            for(let i = 0, l = indices.length; i < l; i++){
	                if (attribute.isInterleavedBufferAttribute) {
	                    index = indices[i] * attribute.data.stride + attribute.offset;
	                } else {
	                    index = indices[i] * itemSize;
	                }
	                for(let j = 0; j < itemSize; j++){
	                    array2[index2++] = array[index++];
	                }
	            }
	            return new BufferAttribute(array2, itemSize, normalized);
	        }
	        //
	        if (this.index === null) {
	            console.warn('THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed.');
	            return this;
	        }
	        const geometry2 = new BufferGeometry();
	        const indices = this.index.array;
	        const attributes = this.attributes;
	        // attributes
	        for(const name in attributes){
	            const attribute = attributes[name];
	            const newAttribute = convertBufferAttribute(attribute, indices);
	            geometry2.setAttribute(name, newAttribute);
	        }
	        // morph attributes
	        const morphAttributes = this.morphAttributes;
	        for(const name in morphAttributes){
	            const morphArray = [];
	            const morphAttribute = morphAttributes[name]; // morphAttribute: array of Float32BufferAttributes
	            for(let i = 0, il = morphAttribute.length; i < il; i++){
	                const attribute = morphAttribute[i];
	                const newAttribute = convertBufferAttribute(attribute, indices);
	                morphArray.push(newAttribute);
	            }
	            geometry2.morphAttributes[name] = morphArray;
	        }
	        geometry2.morphTargetsRelative = this.morphTargetsRelative;
	        // groups
	        const groups = this.groups;
	        for(let i = 0, l = groups.length; i < l; i++){
	            const group = groups[i];
	            geometry2.addGroup(group.start, group.count, group.materialIndex);
	        }
	        return geometry2;
	    }
	    toJSON() {
	        const data = {
	            metadata: {
	                version: 4.6,
	                type: 'BufferGeometry',
	                generator: 'BufferGeometry.toJSON'
	            }
	        };
	        // standard BufferGeometry serialization
	        data.uuid = this.uuid;
	        data.type = this.type;
	        if (this.name !== '') data.name = this.name;
	        if (Object.keys(this.userData).length > 0) data.userData = this.userData;
	        if (this.parameters !== undefined) {
	            const parameters = this.parameters;
	            for(const key in parameters){
	                if (parameters[key] !== undefined) data[key] = parameters[key];
	            }
	            return data;
	        }
	        // for simplicity the code assumes attributes are not shared across geometries, see #15811
	        data.data = {
	            attributes: {}
	        };
	        const index = this.index;
	        if (index !== null) {
	            data.data.index = {
	                type: index.array.constructor.name,
	                array: Array.prototype.slice.call(index.array)
	            };
	        }
	        const attributes = this.attributes;
	        for(const key in attributes){
	            const attribute = attributes[key];
	            data.data.attributes[key] = attribute.toJSON(data.data);
	        }
	        const morphAttributes = {};
	        let hasMorphAttributes = false;
	        for(const key in this.morphAttributes){
	            const attributeArray = this.morphAttributes[key];
	            const array = [];
	            for(let i = 0, il = attributeArray.length; i < il; i++){
	                const attribute = attributeArray[i];
	                array.push(attribute.toJSON(data.data));
	            }
	            if (array.length > 0) {
	                morphAttributes[key] = array;
	                hasMorphAttributes = true;
	            }
	        }
	        if (hasMorphAttributes) {
	            data.data.morphAttributes = morphAttributes;
	            data.data.morphTargetsRelative = this.morphTargetsRelative;
	        }
	        const groups = this.groups;
	        if (groups.length > 0) {
	            data.data.groups = JSON.parse(JSON.stringify(groups));
	        }
	        const boundingSphere = this.boundingSphere;
	        if (boundingSphere !== null) {
	            data.data.boundingSphere = {
	                center: boundingSphere.center.toArray(),
	                radius: boundingSphere.radius
	            };
	        }
	        return data;
	    }
	    clone() {
	        return new this.constructor().copy(this);
	    }
	    copy(source) {
	        // reset
	        this.index = null;
	        this.attributes = {};
	        this.morphAttributes = {};
	        this.groups = [];
	        this.boundingBox = null;
	        this.boundingSphere = null;
	        // used for storing cloned, shared data
	        const data = {};
	        // name
	        this.name = source.name;
	        // index
	        const index = source.index;
	        if (index !== null) {
	            this.setIndex(index.clone(data));
	        }
	        // attributes
	        const attributes = source.attributes;
	        for(const name in attributes){
	            const attribute = attributes[name];
	            this.setAttribute(name, attribute.clone(data));
	        }
	        // morph attributes
	        const morphAttributes = source.morphAttributes;
	        for(const name in morphAttributes){
	            const array = [];
	            const morphAttribute = morphAttributes[name]; // morphAttribute: array of Float32BufferAttributes
	            for(let i = 0, l = morphAttribute.length; i < l; i++){
	                array.push(morphAttribute[i].clone(data));
	            }
	            this.morphAttributes[name] = array;
	        }
	        this.morphTargetsRelative = source.morphTargetsRelative;
	        // groups
	        const groups = source.groups;
	        for(let i = 0, l = groups.length; i < l; i++){
	            const group = groups[i];
	            this.addGroup(group.start, group.count, group.materialIndex);
	        }
	        // bounding box
	        const boundingBox = source.boundingBox;
	        if (boundingBox !== null) {
	            this.boundingBox = boundingBox.clone();
	        }
	        // bounding sphere
	        const boundingSphere = source.boundingSphere;
	        if (boundingSphere !== null) {
	            this.boundingSphere = boundingSphere.clone();
	        }
	        // draw range
	        this.drawRange.start = source.drawRange.start;
	        this.drawRange.count = source.drawRange.count;
	        // user data
	        this.userData = source.userData;
	        return this;
	    }
	    dispose() {
	        this.dispatchEvent({
	            type: 'dispose'
	        });
	    }
	    constructor(){
	        super();
	        this.isBufferGeometry = true;
	        Object.defineProperty(this, 'id', {
	            value: _id$1++
	        });
	        this.uuid = generateUUID();
	        this.name = '';
	        this.type = 'BufferGeometry';
	        this.index = null;
	        this.indirect = null;
	        this.attributes = {};
	        this.morphAttributes = {};
	        this.morphTargetsRelative = false;
	        this.groups = [];
	        this.boundingBox = null;
	        this.boundingSphere = null;
	        this.drawRange = {
	            start: 0,
	            count: Infinity
	        };
	        this.userData = {};
	    }
	}
	const _inverseMatrix$3 = /*@__PURE__*/ new Matrix4();
	const _ray$3 = /*@__PURE__*/ new Ray();
	const _sphere$6 = /*@__PURE__*/ new Sphere();
	const _sphereHitAt = /*@__PURE__*/ new Vector3();
	const _vA$1 = /*@__PURE__*/ new Vector3();
	const _vB$1 = /*@__PURE__*/ new Vector3();
	const _vC$1 = /*@__PURE__*/ new Vector3();
	const _tempA = /*@__PURE__*/ new Vector3();
	const _morphA = /*@__PURE__*/ new Vector3();
	const _intersectionPoint = /*@__PURE__*/ new Vector3();
	const _intersectionPointWorld = /*@__PURE__*/ new Vector3();
	/**
	 * Class representing triangular polygon mesh based objects.
	 *
	 * ```js
	 * const geometry = new THREE.BoxGeometry( 1, 1, 1 );
	 * const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
	 * const mesh = new THREE.Mesh( geometry, material );
	 * scene.add( mesh );
	 * ```
	 *
	 * @augments Object3D
	 */ class Mesh extends Object3D {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        if (source.morphTargetInfluences !== undefined) {
	            this.morphTargetInfluences = source.morphTargetInfluences.slice();
	        }
	        if (source.morphTargetDictionary !== undefined) {
	            this.morphTargetDictionary = Object.assign({}, source.morphTargetDictionary);
	        }
	        this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
	        this.geometry = source.geometry;
	        return this;
	    }
	    /**
		 * Sets the values of {@link Mesh#morphTargetDictionary} and {@link Mesh#morphTargetInfluences}
		 * to make sure existing morph targets can influence this 3D object.
		 */ updateMorphTargets() {
	        const geometry = this.geometry;
	        const morphAttributes = geometry.morphAttributes;
	        const keys = Object.keys(morphAttributes);
	        if (keys.length > 0) {
	            const morphAttribute = morphAttributes[keys[0]];
	            if (morphAttribute !== undefined) {
	                this.morphTargetInfluences = [];
	                this.morphTargetDictionary = {};
	                for(let m = 0, ml = morphAttribute.length; m < ml; m++){
	                    const name = morphAttribute[m].name || String(m);
	                    this.morphTargetInfluences.push(0);
	                    this.morphTargetDictionary[name] = m;
	                }
	            }
	        }
	    }
	    /**
		 * Returns the local-space position of the vertex at the given index, taking into
		 * account the current animation state of both morph targets and skinning.
		 *
		 * @param {number} index - The vertex index.
		 * @param {Vector3} target - The target object that is used to store the method's result.
		 * @return {Vector3} The vertex position in local space.
		 */ getVertexPosition(index, target) {
	        const geometry = this.geometry;
	        const position = geometry.attributes.position;
	        const morphPosition = geometry.morphAttributes.position;
	        const morphTargetsRelative = geometry.morphTargetsRelative;
	        target.fromBufferAttribute(position, index);
	        const morphInfluences = this.morphTargetInfluences;
	        if (morphPosition && morphInfluences) {
	            _morphA.set(0, 0, 0);
	            for(let i = 0, il = morphPosition.length; i < il; i++){
	                const influence = morphInfluences[i];
	                const morphAttribute = morphPosition[i];
	                if (influence === 0) continue;
	                _tempA.fromBufferAttribute(morphAttribute, index);
	                if (morphTargetsRelative) {
	                    _morphA.addScaledVector(_tempA, influence);
	                } else {
	                    _morphA.addScaledVector(_tempA.sub(target), influence);
	                }
	            }
	            target.add(_morphA);
	        }
	        return target;
	    }
	    /**
		 * Computes intersection points between a casted ray and this line.
		 *
		 * @param {Raycaster} raycaster - The raycaster.
		 * @param {Array<Object>} intersects - The target array that holds the intersection points.
		 */ raycast(raycaster, intersects) {
	        const geometry = this.geometry;
	        const material = this.material;
	        const matrixWorld = this.matrixWorld;
	        if (material === undefined) return;
	        // test with bounding sphere in world space
	        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
	        _sphere$6.copy(geometry.boundingSphere);
	        _sphere$6.applyMatrix4(matrixWorld);
	        // check distance from ray origin to bounding sphere
	        _ray$3.copy(raycaster.ray).recast(raycaster.near);
	        if (_sphere$6.containsPoint(_ray$3.origin) === false) {
	            if (_ray$3.intersectSphere(_sphere$6, _sphereHitAt) === null) return;
	            if (_ray$3.origin.distanceToSquared(_sphereHitAt) > (raycaster.far - raycaster.near) ** 2) return;
	        }
	        // convert ray to local space of mesh
	        _inverseMatrix$3.copy(matrixWorld).invert();
	        _ray$3.copy(raycaster.ray).applyMatrix4(_inverseMatrix$3);
	        // test with bounding box in local space
	        if (geometry.boundingBox !== null) {
	            if (_ray$3.intersectsBox(geometry.boundingBox) === false) return;
	        }
	        // test for intersections with geometry
	        this._computeIntersections(raycaster, intersects, _ray$3);
	    }
	    _computeIntersections(raycaster, intersects, rayLocalSpace) {
	        let intersection;
	        const geometry = this.geometry;
	        const material = this.material;
	        const index = geometry.index;
	        const position = geometry.attributes.position;
	        const uv = geometry.attributes.uv;
	        const uv1 = geometry.attributes.uv1;
	        const normal = geometry.attributes.normal;
	        const groups = geometry.groups;
	        const drawRange = geometry.drawRange;
	        if (index !== null) {
	            // indexed buffer geometry
	            if (Array.isArray(material)) {
	                for(let i = 0, il = groups.length; i < il; i++){
	                    const group = groups[i];
	                    const groupMaterial = material[group.materialIndex];
	                    const start = Math.max(group.start, drawRange.start);
	                    const end = Math.min(index.count, Math.min(group.start + group.count, drawRange.start + drawRange.count));
	                    for(let j = start, jl = end; j < jl; j += 3){
	                        const a = index.getX(j);
	                        const b = index.getX(j + 1);
	                        const c = index.getX(j + 2);
	                        intersection = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
	                        if (intersection) {
	                            intersection.faceIndex = Math.floor(j / 3); // triangle number in indexed buffer semantics
	                            intersection.face.materialIndex = group.materialIndex;
	                            intersects.push(intersection);
	                        }
	                    }
	                }
	            } else {
	                const start = Math.max(0, drawRange.start);
	                const end = Math.min(index.count, drawRange.start + drawRange.count);
	                for(let i = start, il = end; i < il; i += 3){
	                    const a = index.getX(i);
	                    const b = index.getX(i + 1);
	                    const c = index.getX(i + 2);
	                    intersection = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
	                    if (intersection) {
	                        intersection.faceIndex = Math.floor(i / 3); // triangle number in indexed buffer semantics
	                        intersects.push(intersection);
	                    }
	                }
	            }
	        } else if (position !== undefined) {
	            // non-indexed buffer geometry
	            if (Array.isArray(material)) {
	                for(let i = 0, il = groups.length; i < il; i++){
	                    const group = groups[i];
	                    const groupMaterial = material[group.materialIndex];
	                    const start = Math.max(group.start, drawRange.start);
	                    const end = Math.min(position.count, Math.min(group.start + group.count, drawRange.start + drawRange.count));
	                    for(let j = start, jl = end; j < jl; j += 3){
	                        const a = j;
	                        const b = j + 1;
	                        const c = j + 2;
	                        intersection = checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
	                        if (intersection) {
	                            intersection.faceIndex = Math.floor(j / 3); // triangle number in non-indexed buffer semantics
	                            intersection.face.materialIndex = group.materialIndex;
	                            intersects.push(intersection);
	                        }
	                    }
	                }
	            } else {
	                const start = Math.max(0, drawRange.start);
	                const end = Math.min(position.count, drawRange.start + drawRange.count);
	                for(let i = start, il = end; i < il; i += 3){
	                    const a = i;
	                    const b = i + 1;
	                    const c = i + 2;
	                    intersection = checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
	                    if (intersection) {
	                        intersection.faceIndex = Math.floor(i / 3); // triangle number in non-indexed buffer semantics
	                        intersects.push(intersection);
	                    }
	                }
	            }
	        }
	    }
	    /**
		 * Constructs a new mesh.
		 *
		 * @param {BufferGeometry} [geometry] - The mesh geometry.
		 * @param {Material|Array<Material>} [material] - The mesh material.
		 */ constructor(geometry = new BufferGeometry(), material = new MeshBasicMaterial()){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isMesh = true;
	        this.type = 'Mesh';
	        /**
			 * The mesh geometry.
			 *
			 * @type {BufferGeometry}
			 */ this.geometry = geometry;
	        /**
			 * The mesh material.
			 *
			 * @type {Material|Array<Material>}
			 * @default MeshBasicMaterial
			 */ this.material = material;
	        /**
			 * A dictionary representing the morph targets in the geometry. The key is the
			 * morph targets name, the value its attribute index. This member is `undefined`
			 * by default and only set when morph targets are detected in the geometry.
			 *
			 * @type {Object<String,number>|undefined}
			 * @default undefined
			 */ this.morphTargetDictionary = undefined;
	        /**
			 * An array of weights typically in the range `[0,1]` that specify how much of the morph
			 * is applied. This member is `undefined` by default and only set when morph targets are
			 * detected in the geometry.
			 *
			 * @type {Array<number>|undefined}
			 * @default undefined
			 */ this.morphTargetInfluences = undefined;
	        this.updateMorphTargets();
	    }
	}
	function checkIntersection$1(object, material, raycaster, ray, pA, pB, pC, point) {
	    let intersect;
	    if (material.side === BackSide) {
	        intersect = ray.intersectTriangle(pC, pB, pA, true, point);
	    } else {
	        intersect = ray.intersectTriangle(pA, pB, pC, material.side === FrontSide, point);
	    }
	    if (intersect === null) return null;
	    _intersectionPointWorld.copy(point);
	    _intersectionPointWorld.applyMatrix4(object.matrixWorld);
	    const distance = raycaster.ray.origin.distanceTo(_intersectionPointWorld);
	    if (distance < raycaster.near || distance > raycaster.far) return null;
	    return {
	        distance: distance,
	        point: _intersectionPointWorld.clone(),
	        object: object
	    };
	}
	function checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, normal, a, b, c) {
	    object.getVertexPosition(a, _vA$1);
	    object.getVertexPosition(b, _vB$1);
	    object.getVertexPosition(c, _vC$1);
	    const intersection = checkIntersection$1(object, material, raycaster, ray, _vA$1, _vB$1, _vC$1, _intersectionPoint);
	    if (intersection) {
	        const barycoord = new Vector3();
	        Triangle.getBarycoord(_intersectionPoint, _vA$1, _vB$1, _vC$1, barycoord);
	        if (uv) {
	            intersection.uv = Triangle.getInterpolatedAttribute(uv, a, b, c, barycoord, new Vector2());
	        }
	        if (uv1) {
	            intersection.uv1 = Triangle.getInterpolatedAttribute(uv1, a, b, c, barycoord, new Vector2());
	        }
	        if (normal) {
	            intersection.normal = Triangle.getInterpolatedAttribute(normal, a, b, c, barycoord, new Vector3());
	            if (intersection.normal.dot(ray.direction) > 0) {
	                intersection.normal.multiplyScalar(-1);
	            }
	        }
	        const face = {
	            a: a,
	            b: b,
	            c: c,
	            normal: new Vector3(),
	            materialIndex: 0
	        };
	        Triangle.getNormal(_vA$1, _vB$1, _vC$1, face.normal);
	        intersection.face = face;
	        intersection.barycoord = barycoord;
	    }
	    return intersection;
	}
	/**
	 * A geometry class for a rectangular cuboid with a given width, height, and depth.
	 * On creation, the cuboid is centred on the origin, with each edge parallel to one
	 * of the axes.
	 *
	 * ```js
	 * const geometry = new THREE.BoxGeometry( 1, 1, 1 );
	 * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
	 * const cube = new THREE.Mesh( geometry, material );
	 * scene.add( cube );
	 * ```
	 *
	 * @augments BufferGeometry
	 */ class BoxGeometry extends BufferGeometry {
	    copy(source) {
	        super.copy(source);
	        this.parameters = Object.assign({}, source.parameters);
	        return this;
	    }
	    /**
		 * Factory method for creating an instance of this class from the given
		 * JSON object.
		 *
		 * @param {Object} data - A JSON object representing the serialized geometry.
		 * @return {BoxGeometry} A new instance.
		 */ static fromJSON(data) {
	        return new BoxGeometry(data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments);
	    }
	    /**
		 * Constructs a new box geometry.
		 *
		 * @param {number} [width=1] - The width. That is, the length of the edges parallel to the X axis.
		 * @param {number} [height=1] - The height. That is, the length of the edges parallel to the Y axis.
		 * @param {number} [depth=1] - The depth. That is, the length of the edges parallel to the Z axis.
		 * @param {number} [widthSegments=1] - Number of segmented rectangular faces along the width of the sides.
		 * @param {number} [heightSegments=1] - Number of segmented rectangular faces along the height of the sides.
		 * @param {number} [depthSegments=1] - Number of segmented rectangular faces along the depth of the sides.
		 */ constructor(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1){
	        super();
	        this.type = 'BoxGeometry';
	        /**
			 * Holds the constructor parameters that have been
			 * used to generate the geometry. Any modification
			 * after instantiation does not change the geometry.
			 *
			 * @type {Object}
			 */ this.parameters = {
	            width: width,
	            height: height,
	            depth: depth,
	            widthSegments: widthSegments,
	            heightSegments: heightSegments,
	            depthSegments: depthSegments
	        };
	        const scope = this;
	        // segments
	        widthSegments = Math.floor(widthSegments);
	        heightSegments = Math.floor(heightSegments);
	        depthSegments = Math.floor(depthSegments);
	        // buffers
	        const indices = [];
	        const vertices = [];
	        const normals = [];
	        const uvs = [];
	        // helper variables
	        let numberOfVertices = 0;
	        let groupStart = 0;
	        // build each side of the box geometry
	        buildPlane('z', 'y', 'x', -1, -1, depth, height, width, depthSegments, heightSegments, 0); // px
	        buildPlane('z', 'y', 'x', 1, -1, depth, height, -width, depthSegments, heightSegments, 1); // nx
	        buildPlane('x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2); // py
	        buildPlane('x', 'z', 'y', 1, -1, width, depth, -height, widthSegments, depthSegments, 3); // ny
	        buildPlane('x', 'y', 'z', 1, -1, width, height, depth, widthSegments, heightSegments, 4); // pz
	        buildPlane('x', 'y', 'z', -1, -1, width, height, -depth, widthSegments, heightSegments, 5); // nz
	        // build geometry
	        this.setIndex(indices);
	        this.setAttribute('position', new Float32BufferAttribute(vertices, 3));
	        this.setAttribute('normal', new Float32BufferAttribute(normals, 3));
	        this.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
	        function buildPlane(u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex) {
	            const segmentWidth = width / gridX;
	            const segmentHeight = height / gridY;
	            const widthHalf = width / 2;
	            const heightHalf = height / 2;
	            const depthHalf = depth / 2;
	            const gridX1 = gridX + 1;
	            const gridY1 = gridY + 1;
	            let vertexCounter = 0;
	            let groupCount = 0;
	            const vector = new Vector3();
	            // generate vertices, normals and uvs
	            for(let iy = 0; iy < gridY1; iy++){
	                const y = iy * segmentHeight - heightHalf;
	                for(let ix = 0; ix < gridX1; ix++){
	                    const x = ix * segmentWidth - widthHalf;
	                    // set values to correct vector component
	                    vector[u] = x * udir;
	                    vector[v] = y * vdir;
	                    vector[w] = depthHalf;
	                    // now apply vector to vertex buffer
	                    vertices.push(vector.x, vector.y, vector.z);
	                    // set values to correct vector component
	                    vector[u] = 0;
	                    vector[v] = 0;
	                    vector[w] = depth > 0 ? 1 : -1;
	                    // now apply vector to normal buffer
	                    normals.push(vector.x, vector.y, vector.z);
	                    // uvs
	                    uvs.push(ix / gridX);
	                    uvs.push(1 - iy / gridY);
	                    // counters
	                    vertexCounter += 1;
	                }
	            }
	            // indices
	            // 1. you need three indices to draw a single face
	            // 2. a single segment consists of two faces
	            // 3. so we need to generate six (2*3) indices per segment
	            for(let iy = 0; iy < gridY; iy++){
	                for(let ix = 0; ix < gridX; ix++){
	                    const a = numberOfVertices + ix + gridX1 * iy;
	                    const b = numberOfVertices + ix + gridX1 * (iy + 1);
	                    const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1);
	                    const d = numberOfVertices + (ix + 1) + gridX1 * iy;
	                    // faces
	                    indices.push(a, b, d);
	                    indices.push(b, c, d);
	                    // increase counter
	                    groupCount += 6;
	                }
	            }
	            // add a group to the geometry. this will ensure multi material support
	            scope.addGroup(groupStart, groupCount, materialIndex);
	            // calculate new start value for groups
	            groupStart += groupCount;
	            // update total number of vertices
	            numberOfVertices += vertexCounter;
	        }
	    }
	}
	/**
	 * Uniform Utilities
	 */ function cloneUniforms(src) {
	    const dst = {};
	    for(const u in src){
	        dst[u] = {};
	        for(const p in src[u]){
	            const property = src[u][p];
	            if (property && (property.isColor || property.isMatrix3 || property.isMatrix4 || property.isVector2 || property.isVector3 || property.isVector4 || property.isTexture || property.isQuaternion)) {
	                if (property.isRenderTargetTexture) {
	                    console.warn('UniformsUtils: Textures of render targets cannot be cloned via cloneUniforms() or mergeUniforms().');
	                    dst[u][p] = null;
	                } else {
	                    dst[u][p] = property.clone();
	                }
	            } else if (Array.isArray(property)) {
	                dst[u][p] = property.slice();
	            } else {
	                dst[u][p] = property;
	            }
	        }
	    }
	    return dst;
	}
	function mergeUniforms(uniforms) {
	    const merged = {};
	    for(let u = 0; u < uniforms.length; u++){
	        const tmp = cloneUniforms(uniforms[u]);
	        for(const p in tmp){
	            merged[p] = tmp[p];
	        }
	    }
	    return merged;
	}
	function cloneUniformsGroups(src) {
	    const dst = [];
	    for(let u = 0; u < src.length; u++){
	        dst.push(src[u].clone());
	    }
	    return dst;
	}
	function getUnlitUniformColorSpace(renderer) {
	    const currentRenderTarget = renderer.getRenderTarget();
	    if (currentRenderTarget === null) {
	        // https://github.com/mrdoob/three.js/pull/23937#issuecomment-1111067398
	        return renderer.outputColorSpace;
	    }
	    // https://github.com/mrdoob/three.js/issues/27868
	    if (currentRenderTarget.isXRRenderTarget === true) {
	        return currentRenderTarget.texture.colorSpace;
	    }
	    return ColorManagement.workingColorSpace;
	}
	// Legacy
	const UniformsUtils = {
	    clone: cloneUniforms,
	    merge: mergeUniforms
	};
	var default_vertex = "void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";
	var default_fragment = "void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}";
	class ShaderMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.fragmentShader = source.fragmentShader;
	        this.vertexShader = source.vertexShader;
	        this.uniforms = cloneUniforms(source.uniforms);
	        this.uniformsGroups = cloneUniformsGroups(source.uniformsGroups);
	        this.defines = Object.assign({}, source.defines);
	        this.wireframe = source.wireframe;
	        this.wireframeLinewidth = source.wireframeLinewidth;
	        this.fog = source.fog;
	        this.lights = source.lights;
	        this.clipping = source.clipping;
	        this.extensions = Object.assign({}, source.extensions);
	        this.glslVersion = source.glslVersion;
	        return this;
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        data.glslVersion = this.glslVersion;
	        data.uniforms = {};
	        for(const name in this.uniforms){
	            const uniform = this.uniforms[name];
	            const value = uniform.value;
	            if (value && value.isTexture) {
	                data.uniforms[name] = {
	                    type: 't',
	                    value: value.toJSON(meta).uuid
	                };
	            } else if (value && value.isColor) {
	                data.uniforms[name] = {
	                    type: 'c',
	                    value: value.getHex()
	                };
	            } else if (value && value.isVector2) {
	                data.uniforms[name] = {
	                    type: 'v2',
	                    value: value.toArray()
	                };
	            } else if (value && value.isVector3) {
	                data.uniforms[name] = {
	                    type: 'v3',
	                    value: value.toArray()
	                };
	            } else if (value && value.isVector4) {
	                data.uniforms[name] = {
	                    type: 'v4',
	                    value: value.toArray()
	                };
	            } else if (value && value.isMatrix3) {
	                data.uniforms[name] = {
	                    type: 'm3',
	                    value: value.toArray()
	                };
	            } else if (value && value.isMatrix4) {
	                data.uniforms[name] = {
	                    type: 'm4',
	                    value: value.toArray()
	                };
	            } else {
	                data.uniforms[name] = {
	                    value: value
	                };
	            // note: the array variants v2v, v3v, v4v, m4v and tv are not supported so far
	            }
	        }
	        if (Object.keys(this.defines).length > 0) data.defines = this.defines;
	        data.vertexShader = this.vertexShader;
	        data.fragmentShader = this.fragmentShader;
	        data.lights = this.lights;
	        data.clipping = this.clipping;
	        const extensions = {};
	        for(const key in this.extensions){
	            if (this.extensions[key] === true) extensions[key] = true;
	        }
	        if (Object.keys(extensions).length > 0) data.extensions = extensions;
	        return data;
	    }
	    constructor(parameters){
	        super();
	        this.isShaderMaterial = true;
	        this.type = 'ShaderMaterial';
	        this.defines = {};
	        this.uniforms = {};
	        this.uniformsGroups = [];
	        this.vertexShader = default_vertex;
	        this.fragmentShader = default_fragment;
	        this.linewidth = 1;
	        this.wireframe = false;
	        this.wireframeLinewidth = 1;
	        this.fog = false; // set to use scene fog
	        this.lights = false; // set to use scene lights
	        this.clipping = false; // set to use user-defined clipping planes
	        this.forceSinglePass = true;
	        this.extensions = {
	            clipCullDistance: false,
	            multiDraw: false // set to use vertex shader multi_draw / enable gl_DrawID
	        };
	        // When rendered geometry doesn't include these attributes but the material does,
	        // use these default values in WebGL. This avoids errors when buffer data is missing.
	        this.defaultAttributeValues = {
	            'color': [
	                1,
	                1,
	                1
	            ],
	            'uv': [
	                0,
	                0
	            ],
	            'uv1': [
	                0,
	                0
	            ]
	        };
	        this.index0AttributeName = undefined;
	        this.uniformsNeedUpdate = false;
	        this.glslVersion = null;
	        if (parameters !== undefined) {
	            this.setValues(parameters);
	        }
	    }
	}
	/**
	 * Abstract base class for cameras. This class should always be inherited
	 * when you build a new camera.
	 *
	 * @abstract
	 * @augments Object3D
	 */ class Camera extends Object3D {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.matrixWorldInverse.copy(source.matrixWorldInverse);
	        this.projectionMatrix.copy(source.projectionMatrix);
	        this.projectionMatrixInverse.copy(source.projectionMatrixInverse);
	        this.coordinateSystem = source.coordinateSystem;
	        return this;
	    }
	    /**
		 * Returns a vector representing the ("look") direction of the 3D object in world space.
		 *
		 * This method is overwritten since cameras have a different forward vector compared to other
		 * 3D objects. A camera looks down its local, negative z-axis by default.
		 *
		 * @param {Vector3} target - The target vector the result is stored to.
		 * @return {Vector3} The 3D object's direction in world space.
		 */ getWorldDirection(target) {
	        return super.getWorldDirection(target).negate();
	    }
	    updateMatrixWorld(force) {
	        super.updateMatrixWorld(force);
	        this.matrixWorldInverse.copy(this.matrixWorld).invert();
	    }
	    updateWorldMatrix(updateParents, updateChildren) {
	        super.updateWorldMatrix(updateParents, updateChildren);
	        this.matrixWorldInverse.copy(this.matrixWorld).invert();
	    }
	    clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Constructs a new camera.
		 */ constructor(){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isCamera = true;
	        this.type = 'Camera';
	        /**
			 * The inverse of the camera's world matrix.
			 *
			 * @type {Matrix4}
			 */ this.matrixWorldInverse = new Matrix4();
	        /**
			 * The camera's projection matrix.
			 *
			 * @type {Matrix4}
			 */ this.projectionMatrix = new Matrix4();
	        /**
			 * The inverse of the camera's projection matrix.
			 *
			 * @type {Matrix4}
			 */ this.projectionMatrixInverse = new Matrix4();
	        /**
			 * The coordinate system in which the camera is used.
			 *
			 * @type {(WebGLCoordinateSystem|WebGPUCoordinateSystem)}
			 */ this.coordinateSystem = WebGLCoordinateSystem;
	    }
	}
	const _v3$1 = /*@__PURE__*/ new Vector3();
	const _minTarget = /*@__PURE__*/ new Vector2();
	const _maxTarget = /*@__PURE__*/ new Vector2();
	/**
	 * Camera that uses [perspective projection]{@link https://en.wikipedia.org/wiki/Perspective_(graphical)}.
	 *
	 * This projection mode is designed to mimic the way the human eye sees. It
	 * is the most common projection mode used for rendering a 3D scene.
	 *
	 * ```js
	 * const camera = new THREE.PerspectiveCamera( 45, width / height, 1, 1000 );
	 * scene.add( camera );
	 * ```
	 *
	 * @augments Camera
	 */ class PerspectiveCamera extends Camera {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.fov = source.fov;
	        this.zoom = source.zoom;
	        this.near = source.near;
	        this.far = source.far;
	        this.focus = source.focus;
	        this.aspect = source.aspect;
	        this.view = source.view === null ? null : Object.assign({}, source.view);
	        this.filmGauge = source.filmGauge;
	        this.filmOffset = source.filmOffset;
	        return this;
	    }
	    /**
		 * Sets the FOV by focal length in respect to the current {@link PerspectiveCamera#filmGauge}.
		 *
		 * The default film gauge is 35, so that the focal length can be specified for
		 * a 35mm (full frame) camera.
		 *
		 * @param {number} focalLength - Values for focal length and film gauge must have the same unit.
		 */ setFocalLength(focalLength) {
	        /** see {@link http://www.bobatkins.com/photography/technical/field_of_view.html} */ const vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;
	        this.fov = RAD2DEG * 2 * Math.atan(vExtentSlope);
	        this.updateProjectionMatrix();
	    }
	    /**
		 * Returns the focal length from the current {@link PerspectiveCamera#fov} and
		 * {@link PerspectiveCamera#filmGauge}.
		 *
		 * @return {number} The computed focal length.
		 */ getFocalLength() {
	        const vExtentSlope = Math.tan(DEG2RAD * 0.5 * this.fov);
	        return 0.5 * this.getFilmHeight() / vExtentSlope;
	    }
	    /**
		 * Returns the current vertical field of view angle in degrees considering {@link PerspectiveCamera#zoom}.
		 *
		 * @return {number} The effective FOV.
		 */ getEffectiveFOV() {
	        return RAD2DEG * 2 * Math.atan(Math.tan(DEG2RAD * 0.5 * this.fov) / this.zoom);
	    }
	    /**
		 * Returns the width of the image on the film. If {@link PerspectiveCamera#aspect} is greater than or
		 * equal to one (landscape format), the result equals {@link PerspectiveCamera#filmGauge}.
		 *
		 * @return {number} The film width.
		 */ getFilmWidth() {
	        // film not completely covered in portrait format (aspect < 1)
	        return this.filmGauge * Math.min(this.aspect, 1);
	    }
	    /**
		 * Returns the height of the image on the film. If {@link PerspectiveCamera#aspect} is greater than or
		 * equal to one (landscape format), the result equals {@link PerspectiveCamera#filmGauge}.
		 *
		 * @return {number} The film width.
		 */ getFilmHeight() {
	        // film not completely covered in landscape format (aspect > 1)
	        return this.filmGauge / Math.max(this.aspect, 1);
	    }
	    /**
		 * Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction.
		 * Sets `minTarget` and `maxTarget` to the coordinates of the lower-left and upper-right corners of the view rectangle.
		 *
		 * @param {number} distance - The viewing distance.
		 * @param {Vector2} minTarget - The lower-left corner of the view rectangle is written into this vector.
		 * @param {Vector2} maxTarget - The upper-right corner of the view rectangle is written into this vector.
		 */ getViewBounds(distance, minTarget, maxTarget) {
	        _v3$1.set(-1, -1, 0.5).applyMatrix4(this.projectionMatrixInverse);
	        minTarget.set(_v3$1.x, _v3$1.y).multiplyScalar(-distance / _v3$1.z);
	        _v3$1.set(1, 1, 0.5).applyMatrix4(this.projectionMatrixInverse);
	        maxTarget.set(_v3$1.x, _v3$1.y).multiplyScalar(-distance / _v3$1.z);
	    }
	    /**
		 * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.
		 *
		 * @param {number} distance - The viewing distance.
		 * @param {Vector2} target - The target vector that is used to store result where x is width and y is height.
		 * @returns {Vector2} The view size.
		 */ getViewSize(distance, target) {
	        this.getViewBounds(distance, _minTarget, _maxTarget);
	        return target.subVectors(_maxTarget, _minTarget);
	    }
	    /**
		 * Sets an offset in a larger frustum. This is useful for multi-window or
		 * multi-monitor/multi-machine setups.
		 *
		 * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
		 * the monitors are in grid like this
		 *```
		 *   +---+---+---+
		 *   | A | B | C |
		 *   +---+---+---+
		 *   | D | E | F |
		 *   +---+---+---+
		 *```
		 * then for each monitor you would call it like this:
		 *```js
		 * const w = 1920;
		 * const h = 1080;
		 * const fullWidth = w * 3;
		 * const fullHeight = h * 2;
		 *
		 * // --A--
		 * camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
		 * // --B--
		 * camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
		 * // --C--
		 * camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
		 * // --D--
		 * camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
		 * // --E--
		 * camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
		 * // --F--
		 * camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
		 * ```
		 *
		 * Note there is no reason monitors have to be the same size or in a grid.
		 *
		 * @param {number} fullWidth - The full width of multiview setup.
		 * @param {number} fullHeight - The full height of multiview setup.
		 * @param {number} x - The horizontal offset of the subcamera.
		 * @param {number} y - The vertical offset of the subcamera.
		 * @param {number} width - The width of subcamera.
		 * @param {number} height - The height of subcamera.
		 */ setViewOffset(fullWidth, fullHeight, x, y, width, height) {
	        this.aspect = fullWidth / fullHeight;
	        if (this.view === null) {
	            this.view = {
	                enabled: true,
	                fullWidth: 1,
	                fullHeight: 1,
	                offsetX: 0,
	                offsetY: 0,
	                width: 1,
	                height: 1
	            };
	        }
	        this.view.enabled = true;
	        this.view.fullWidth = fullWidth;
	        this.view.fullHeight = fullHeight;
	        this.view.offsetX = x;
	        this.view.offsetY = y;
	        this.view.width = width;
	        this.view.height = height;
	        this.updateProjectionMatrix();
	    }
	    /**
		 * Removes the view offset from the projection matrix.
		 */ clearViewOffset() {
	        if (this.view !== null) {
	            this.view.enabled = false;
	        }
	        this.updateProjectionMatrix();
	    }
	    /**
		 * Updates the camera's projection matrix. Must be called after any change of
		 * camera properties.
		 */ updateProjectionMatrix() {
	        const near = this.near;
	        let top = near * Math.tan(DEG2RAD * 0.5 * this.fov) / this.zoom;
	        let height = 2 * top;
	        let width = this.aspect * height;
	        let left = -0.5 * width;
	        const view = this.view;
	        if (this.view !== null && this.view.enabled) {
	            const fullWidth = view.fullWidth, fullHeight = view.fullHeight;
	            left += view.offsetX * width / fullWidth;
	            top -= view.offsetY * height / fullHeight;
	            width *= view.width / fullWidth;
	            height *= view.height / fullHeight;
	        }
	        const skew = this.filmOffset;
	        if (skew !== 0) left += near * skew / this.getFilmWidth();
	        this.projectionMatrix.makePerspective(left, left + width, top, top - height, near, this.far, this.coordinateSystem);
	        this.projectionMatrixInverse.copy(this.projectionMatrix).invert();
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        data.object.fov = this.fov;
	        data.object.zoom = this.zoom;
	        data.object.near = this.near;
	        data.object.far = this.far;
	        data.object.focus = this.focus;
	        data.object.aspect = this.aspect;
	        if (this.view !== null) data.object.view = Object.assign({}, this.view);
	        data.object.filmGauge = this.filmGauge;
	        data.object.filmOffset = this.filmOffset;
	        return data;
	    }
	    /**
		 * Constructs a new perspective camera.
		 *
		 * @param {number} [fov=50] - The vertical field of view.
		 * @param {number} [aspect=1] - The aspect ratio.
		 * @param {number} [near=0.1] - The camera's near plane.
		 * @param {number} [far=2000] - The camera's far plane.
		 */ constructor(fov = 50, aspect = 1, near = 0.1, far = 2000){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isPerspectiveCamera = true;
	        this.type = 'PerspectiveCamera';
	        /**
			 * The vertical field of view, from bottom to top of view,
			 * in degrees.
			 *
			 * @type {number}
			 * @default 50
			 */ this.fov = fov;
	        /**
			 * The zoom factor of the camera.
			 *
			 * @type {number}
			 * @default 1
			 */ this.zoom = 1;
	        /**
			 * The camera's near plane. The valid range is greater than `0`
			 * and less than the current value of {@link PerspectiveCamera#far}.
			 *
			 * Note that, unlike for the {@link OrthographicCamera}, `0` is <em>not</em> a
			 * valid value for a perspective camera's near plane.
			 *
			 * @type {number}
			 * @default 0.1
			 */ this.near = near;
	        /**
			 * The camera's far plane. Must be greater than the
			 * current value of {@link PerspectiveCamera#near}.
			 *
			 * @type {number}
			 * @default 2000
			 */ this.far = far;
	        /**
			 * Object distance used for stereoscopy and depth-of-field effects. This
			 * parameter does not influence the projection matrix unless a
			 * {@link StereoCamera} is being used.
			 *
			 * @type {number}
			 * @default 10
			 */ this.focus = 10;
	        /**
			 * The aspect ratio, usually the canvas width / canvas height.
			 *
			 * @type {number}
			 * @default 1
			 */ this.aspect = aspect;
	        /**
			 * Represents the frustum window specification. This property should not be edited
			 * directly but via {@link PerspectiveCamera#setViewOffset} and {@link PerspectiveCamera#clearViewOffset}.
			 *
			 * @type {?Object}
			 * @default null
			 */ this.view = null;
	        /**
			 * Film size used for the larger axis. Default is `35` (millimeters). This
			 * parameter does not influence the projection matrix unless {@link PerspectiveCamera#filmOffset}
			 * is set to a nonzero value.
			 *
			 * @type {number}
			 * @default 35
			 */ this.filmGauge = 35;
	        /**
			 * Horizontal off-center offset in the same unit as {@link PerspectiveCamera#filmGauge}.
			 *
			 * @type {number}
			 * @default 0
			 */ this.filmOffset = 0;
	        this.updateProjectionMatrix();
	    }
	}
	const fov = -90; // negative fov is not an error
	const aspect = 1;
	/**
	 * A special type of camera that is positioned in 3D space to render its surroundings into a
	 * cube render target. The render target can then be used as an environment map for rendering
	 * realtime reflections in your scene.
	 *
	 * ```js
	 * // Create cube render target
	 * const cubeRenderTarget = new THREE.WebGLCubeRenderTarget( 256, { generateMipmaps: true, minFilter: THREE.LinearMipmapLinearFilter } );
	 *
	 * // Create cube camera
	 * const cubeCamera = new THREE.CubeCamera( 1, 100000, cubeRenderTarget );
	 * scene.add( cubeCamera );
	 *
	 * // Create car
	 * const chromeMaterial = new THREE.MeshLambertMaterial( { color: 0xffffff, envMap: cubeRenderTarget.texture } );
	 * const car = new THREE.Mesh( carGeometry, chromeMaterial );
	 * scene.add( car );
	 *
	 * // Update the render target cube
	 * car.visible = false;
	 * cubeCamera.position.copy( car.position );
	 * cubeCamera.update( renderer, scene );
	 *
	 * // Render the scene
	 * car.visible = true;
	 * renderer.render( scene, camera );
	 * ```
	 *
	 * @augments Object3D
	 */ class CubeCamera extends Object3D {
	    /**
		 * Must be called when the coordinate system of the cube camera is changed.
		 */ updateCoordinateSystem() {
	        const coordinateSystem = this.coordinateSystem;
	        const cameras = this.children.concat();
	        const [cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ] = cameras;
	        for (const camera of cameras)this.remove(camera);
	        if (coordinateSystem === WebGLCoordinateSystem) {
	            cameraPX.up.set(0, 1, 0);
	            cameraPX.lookAt(1, 0, 0);
	            cameraNX.up.set(0, 1, 0);
	            cameraNX.lookAt(-1, 0, 0);
	            cameraPY.up.set(0, 0, -1);
	            cameraPY.lookAt(0, 1, 0);
	            cameraNY.up.set(0, 0, 1);
	            cameraNY.lookAt(0, -1, 0);
	            cameraPZ.up.set(0, 1, 0);
	            cameraPZ.lookAt(0, 0, 1);
	            cameraNZ.up.set(0, 1, 0);
	            cameraNZ.lookAt(0, 0, -1);
	        } else if (coordinateSystem === WebGPUCoordinateSystem) {
	            cameraPX.up.set(0, -1, 0);
	            cameraPX.lookAt(-1, 0, 0);
	            cameraNX.up.set(0, -1, 0);
	            cameraNX.lookAt(1, 0, 0);
	            cameraPY.up.set(0, 0, 1);
	            cameraPY.lookAt(0, 1, 0);
	            cameraNY.up.set(0, 0, -1);
	            cameraNY.lookAt(0, -1, 0);
	            cameraPZ.up.set(0, -1, 0);
	            cameraPZ.lookAt(0, 0, 1);
	            cameraNZ.up.set(0, -1, 0);
	            cameraNZ.lookAt(0, 0, -1);
	        } else {
	            throw new Error('THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: ' + coordinateSystem);
	        }
	        for (const camera of cameras){
	            this.add(camera);
	            camera.updateMatrixWorld();
	        }
	    }
	    /**
		 * Calling this method will render the given scene with the given renderer
		 * into the cube render target of the camera.
		 *
		 * @param {(Renderer|WebGLRenderer)} renderer - The renderer.
		 * @param {Scene} scene - The scene to render.
		 */ update(renderer, scene) {
	        if (this.parent === null) this.updateMatrixWorld();
	        const { renderTarget, activeMipmapLevel } = this;
	        if (this.coordinateSystem !== renderer.coordinateSystem) {
	            this.coordinateSystem = renderer.coordinateSystem;
	            this.updateCoordinateSystem();
	        }
	        const [cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ] = this.children;
	        const currentRenderTarget = renderer.getRenderTarget();
	        const currentActiveCubeFace = renderer.getActiveCubeFace();
	        const currentActiveMipmapLevel = renderer.getActiveMipmapLevel();
	        const currentXrEnabled = renderer.xr.enabled;
	        renderer.xr.enabled = false;
	        const generateMipmaps = renderTarget.texture.generateMipmaps;
	        renderTarget.texture.generateMipmaps = false;
	        renderer.setRenderTarget(renderTarget, 0, activeMipmapLevel);
	        renderer.render(scene, cameraPX);
	        renderer.setRenderTarget(renderTarget, 1, activeMipmapLevel);
	        renderer.render(scene, cameraNX);
	        renderer.setRenderTarget(renderTarget, 2, activeMipmapLevel);
	        renderer.render(scene, cameraPY);
	        renderer.setRenderTarget(renderTarget, 3, activeMipmapLevel);
	        renderer.render(scene, cameraNY);
	        renderer.setRenderTarget(renderTarget, 4, activeMipmapLevel);
	        renderer.render(scene, cameraPZ);
	        // mipmaps are generated during the last call of render()
	        // at this point, all sides of the cube render target are defined
	        renderTarget.texture.generateMipmaps = generateMipmaps;
	        renderer.setRenderTarget(renderTarget, 5, activeMipmapLevel);
	        renderer.render(scene, cameraNZ);
	        renderer.setRenderTarget(currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel);
	        renderer.xr.enabled = currentXrEnabled;
	        renderTarget.texture.needsPMREMUpdate = true;
	    }
	    /**
		 * Constructs a new cube camera.
		 *
		 * @param {number} near - The camera's near plane.
		 * @param {number} far - The camera's far plane.
		 * @param {WebGLCubeRenderTarget} renderTarget - The cube render target.
		 */ constructor(near, far, renderTarget){
	        super();
	        this.type = 'CubeCamera';
	        /**
			 * A reference to the cube render target.
			 *
			 * @type {WebGLCubeRenderTarget}
			 */ this.renderTarget = renderTarget;
	        /**
			 * The current active coordinate system.
			 *
			 * @type {?(WebGLCoordinateSystem|WebGPUCoordinateSystem)}
			 * @default null
			 */ this.coordinateSystem = null;
	        /**
			 * The current active mipmap level
			 *
			 * @type {number}
			 * @default 0
			 */ this.activeMipmapLevel = 0;
	        const cameraPX = new PerspectiveCamera(fov, aspect, near, far);
	        cameraPX.layers = this.layers;
	        this.add(cameraPX);
	        const cameraNX = new PerspectiveCamera(fov, aspect, near, far);
	        cameraNX.layers = this.layers;
	        this.add(cameraNX);
	        const cameraPY = new PerspectiveCamera(fov, aspect, near, far);
	        cameraPY.layers = this.layers;
	        this.add(cameraPY);
	        const cameraNY = new PerspectiveCamera(fov, aspect, near, far);
	        cameraNY.layers = this.layers;
	        this.add(cameraNY);
	        const cameraPZ = new PerspectiveCamera(fov, aspect, near, far);
	        cameraPZ.layers = this.layers;
	        this.add(cameraPZ);
	        const cameraNZ = new PerspectiveCamera(fov, aspect, near, far);
	        cameraNZ.layers = this.layers;
	        this.add(cameraNZ);
	    }
	}
	class CubeTexture extends Texture$1 {
	    get images() {
	        return this.image;
	    }
	    set images(value) {
	        this.image = value;
	    }
	    constructor(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace){
	        images = images !== undefined ? images : [];
	        mapping = mapping !== undefined ? mapping : CubeReflectionMapping;
	        super(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
	        this.isCubeTexture = true;
	        this.flipY = false;
	    }
	}
	class WebGLCubeRenderTarget extends WebGLRenderTarget {
	    fromEquirectangularTexture(renderer, texture) {
	        this.texture.type = texture.type;
	        this.texture.colorSpace = texture.colorSpace;
	        this.texture.generateMipmaps = texture.generateMipmaps;
	        this.texture.minFilter = texture.minFilter;
	        this.texture.magFilter = texture.magFilter;
	        const shader = {
	            uniforms: {
	                tEquirect: {
	                    value: null
	                }
	            },
	            vertexShader: /* glsl */ `

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,
	            fragmentShader: /* glsl */ `

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`
	        };
	        const geometry = new BoxGeometry(5, 5, 5);
	        const material = new ShaderMaterial({
	            name: 'CubemapFromEquirect',
	            uniforms: cloneUniforms(shader.uniforms),
	            vertexShader: shader.vertexShader,
	            fragmentShader: shader.fragmentShader,
	            side: BackSide,
	            blending: NoBlending
	        });
	        material.uniforms.tEquirect.value = texture;
	        const mesh = new Mesh(geometry, material);
	        const currentMinFilter = texture.minFilter;
	        // Avoid blurred poles
	        if (texture.minFilter === LinearMipmapLinearFilter) texture.minFilter = LinearFilter;
	        const camera = new CubeCamera(1, 10, this);
	        camera.update(renderer, mesh);
	        texture.minFilter = currentMinFilter;
	        mesh.geometry.dispose();
	        mesh.material.dispose();
	        return this;
	    }
	    clear(renderer, color, depth, stencil) {
	        const currentRenderTarget = renderer.getRenderTarget();
	        for(let i = 0; i < 6; i++){
	            renderer.setRenderTarget(this, i);
	            renderer.clear(color, depth, stencil);
	        }
	        renderer.setRenderTarget(currentRenderTarget);
	    }
	    constructor(size = 1, options = {}){
	        super(size, size, options);
	        this.isWebGLCubeRenderTarget = true;
	        const image = {
	            width: size,
	            height: size,
	            depth: 1
	        };
	        const images = [
	            image,
	            image,
	            image,
	            image,
	            image,
	            image
	        ];
	        this.texture = new CubeTexture(images, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace);
	        // By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)
	        // in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,
	        // in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.
	        // three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
	        // and the flag isRenderTargetTexture controls this conversion. The flip is not required when using WebGLCubeRenderTarget.texture
	        // as a cube texture (this is detected when isRenderTargetTexture is set to true for cube textures).
	        this.texture.isRenderTargetTexture = true;
	        this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
	        this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;
	    }
	}
	/**
	 * This is almost identical to an {@link Object3D}. Its purpose is to
	 * make working with groups of objects syntactically clearer.
	 *
	 * ```js
	 * // Create a group and add the two cubes.
	 * // These cubes can now be rotated / scaled etc as a group.
	 * const group = new THREE.Group();
	 *
	 * group.add( meshA );
	 * group.add( meshB );
	 *
	 * scene.add( group );
	 * ```
	 *
	 * @augments Object3D
	 */ class Group extends Object3D {
	    constructor(){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isGroup = true;
	        this.type = 'Group';
	    }
	}
	const _moveEvent = {
	    type: 'move'
	};
	class WebXRController {
	    getHandSpace() {
	        if (this._hand === null) {
	            this._hand = new Group();
	            this._hand.matrixAutoUpdate = false;
	            this._hand.visible = false;
	            this._hand.joints = {};
	            this._hand.inputState = {
	                pinching: false
	            };
	        }
	        return this._hand;
	    }
	    getTargetRaySpace() {
	        if (this._targetRay === null) {
	            this._targetRay = new Group();
	            this._targetRay.matrixAutoUpdate = false;
	            this._targetRay.visible = false;
	            this._targetRay.hasLinearVelocity = false;
	            this._targetRay.linearVelocity = new Vector3();
	            this._targetRay.hasAngularVelocity = false;
	            this._targetRay.angularVelocity = new Vector3();
	        }
	        return this._targetRay;
	    }
	    getGripSpace() {
	        if (this._grip === null) {
	            this._grip = new Group();
	            this._grip.matrixAutoUpdate = false;
	            this._grip.visible = false;
	            this._grip.hasLinearVelocity = false;
	            this._grip.linearVelocity = new Vector3();
	            this._grip.hasAngularVelocity = false;
	            this._grip.angularVelocity = new Vector3();
	        }
	        return this._grip;
	    }
	    dispatchEvent(event) {
	        if (this._targetRay !== null) {
	            this._targetRay.dispatchEvent(event);
	        }
	        if (this._grip !== null) {
	            this._grip.dispatchEvent(event);
	        }
	        if (this._hand !== null) {
	            this._hand.dispatchEvent(event);
	        }
	        return this;
	    }
	    connect(inputSource) {
	        if (inputSource && inputSource.hand) {
	            const hand = this._hand;
	            if (hand) {
	                for (const inputjoint of inputSource.hand.values()){
	                    // Initialize hand with joints when connected
	                    this._getHandJoint(hand, inputjoint);
	                }
	            }
	        }
	        this.dispatchEvent({
	            type: 'connected',
	            data: inputSource
	        });
	        return this;
	    }
	    disconnect(inputSource) {
	        this.dispatchEvent({
	            type: 'disconnected',
	            data: inputSource
	        });
	        if (this._targetRay !== null) {
	            this._targetRay.visible = false;
	        }
	        if (this._grip !== null) {
	            this._grip.visible = false;
	        }
	        if (this._hand !== null) {
	            this._hand.visible = false;
	        }
	        return this;
	    }
	    update(inputSource, frame, referenceSpace) {
	        let inputPose = null;
	        let gripPose = null;
	        let handPose = null;
	        const targetRay = this._targetRay;
	        const grip = this._grip;
	        const hand = this._hand;
	        if (inputSource && frame.session.visibilityState !== 'visible-blurred') {
	            if (hand && inputSource.hand) {
	                handPose = true;
	                for (const inputjoint of inputSource.hand.values()){
	                    // Update the joints groups with the XRJoint poses
	                    const jointPose = frame.getJointPose(inputjoint, referenceSpace);
	                    // The transform of this joint will be updated with the joint pose on each frame
	                    const joint = this._getHandJoint(hand, inputjoint);
	                    if (jointPose !== null) {
	                        joint.matrix.fromArray(jointPose.transform.matrix);
	                        joint.matrix.decompose(joint.position, joint.rotation, joint.scale);
	                        joint.matrixWorldNeedsUpdate = true;
	                        joint.jointRadius = jointPose.radius;
	                    }
	                    joint.visible = jointPose !== null;
	                }
	                // Custom events
	                // Check pinchz
	                const indexTip = hand.joints['index-finger-tip'];
	                const thumbTip = hand.joints['thumb-tip'];
	                const distance = indexTip.position.distanceTo(thumbTip.position);
	                const distanceToPinch = 0.02;
	                const threshold = 0.005;
	                if (hand.inputState.pinching && distance > distanceToPinch + threshold) {
	                    hand.inputState.pinching = false;
	                    this.dispatchEvent({
	                        type: 'pinchend',
	                        handedness: inputSource.handedness,
	                        target: this
	                    });
	                } else if (!hand.inputState.pinching && distance <= distanceToPinch - threshold) {
	                    hand.inputState.pinching = true;
	                    this.dispatchEvent({
	                        type: 'pinchstart',
	                        handedness: inputSource.handedness,
	                        target: this
	                    });
	                }
	            } else {
	                if (grip !== null && inputSource.gripSpace) {
	                    gripPose = frame.getPose(inputSource.gripSpace, referenceSpace);
	                    if (gripPose !== null) {
	                        grip.matrix.fromArray(gripPose.transform.matrix);
	                        grip.matrix.decompose(grip.position, grip.rotation, grip.scale);
	                        grip.matrixWorldNeedsUpdate = true;
	                        if (gripPose.linearVelocity) {
	                            grip.hasLinearVelocity = true;
	                            grip.linearVelocity.copy(gripPose.linearVelocity);
	                        } else {
	                            grip.hasLinearVelocity = false;
	                        }
	                        if (gripPose.angularVelocity) {
	                            grip.hasAngularVelocity = true;
	                            grip.angularVelocity.copy(gripPose.angularVelocity);
	                        } else {
	                            grip.hasAngularVelocity = false;
	                        }
	                    }
	                }
	            }
	            if (targetRay !== null) {
	                inputPose = frame.getPose(inputSource.targetRaySpace, referenceSpace);
	                // Some runtimes (namely Vive Cosmos with Vive OpenXR Runtime) have only grip space and ray space is equal to it
	                if (inputPose === null && gripPose !== null) {
	                    inputPose = gripPose;
	                }
	                if (inputPose !== null) {
	                    targetRay.matrix.fromArray(inputPose.transform.matrix);
	                    targetRay.matrix.decompose(targetRay.position, targetRay.rotation, targetRay.scale);
	                    targetRay.matrixWorldNeedsUpdate = true;
	                    if (inputPose.linearVelocity) {
	                        targetRay.hasLinearVelocity = true;
	                        targetRay.linearVelocity.copy(inputPose.linearVelocity);
	                    } else {
	                        targetRay.hasLinearVelocity = false;
	                    }
	                    if (inputPose.angularVelocity) {
	                        targetRay.hasAngularVelocity = true;
	                        targetRay.angularVelocity.copy(inputPose.angularVelocity);
	                    } else {
	                        targetRay.hasAngularVelocity = false;
	                    }
	                    this.dispatchEvent(_moveEvent);
	                }
	            }
	        }
	        if (targetRay !== null) {
	            targetRay.visible = inputPose !== null;
	        }
	        if (grip !== null) {
	            grip.visible = gripPose !== null;
	        }
	        if (hand !== null) {
	            hand.visible = handPose !== null;
	        }
	        return this;
	    }
	    // private method
	    _getHandJoint(hand, inputjoint) {
	        if (hand.joints[inputjoint.jointName] === undefined) {
	            const joint = new Group();
	            joint.matrixAutoUpdate = false;
	            joint.visible = false;
	            hand.joints[inputjoint.jointName] = joint;
	            hand.add(joint);
	        }
	        return hand.joints[inputjoint.jointName];
	    }
	    constructor(){
	        this._targetRay = null;
	        this._grip = null;
	        this._hand = null;
	    }
	}
	/**
	 * Scenes allow you to set up what is to be rendered and where by three.js.
	 * This is where you place 3D objects like meshes, lines or lights.
	 *
	 * @augments Object3D
	 */ class Scene extends Object3D {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        if (source.background !== null) this.background = source.background.clone();
	        if (source.environment !== null) this.environment = source.environment.clone();
	        if (source.fog !== null) this.fog = source.fog.clone();
	        this.backgroundBlurriness = source.backgroundBlurriness;
	        this.backgroundIntensity = source.backgroundIntensity;
	        this.backgroundRotation.copy(source.backgroundRotation);
	        this.environmentIntensity = source.environmentIntensity;
	        this.environmentRotation.copy(source.environmentRotation);
	        if (source.overrideMaterial !== null) this.overrideMaterial = source.overrideMaterial.clone();
	        this.matrixAutoUpdate = source.matrixAutoUpdate;
	        return this;
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        if (this.fog !== null) data.object.fog = this.fog.toJSON();
	        if (this.backgroundBlurriness > 0) data.object.backgroundBlurriness = this.backgroundBlurriness;
	        if (this.backgroundIntensity !== 1) data.object.backgroundIntensity = this.backgroundIntensity;
	        data.object.backgroundRotation = this.backgroundRotation.toArray();
	        if (this.environmentIntensity !== 1) data.object.environmentIntensity = this.environmentIntensity;
	        data.object.environmentRotation = this.environmentRotation.toArray();
	        return data;
	    }
	    /**
		 * Constructs a new scene.
		 */ constructor(){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isScene = true;
	        this.type = 'Scene';
	        /**
			 * Defines the background of the scene. Valid inputs are:
			 *
			 * - A color for defining a uniform colored background.
			 * - A texture for defining a (flat) textured background.
			 * - Cube textures or equirectangular textures for defining a skybox.
			 *
			 * @type {?(Color|Texture)}
			 * @default null
			 */ this.background = null;
	        /**
			 * Sets the environment map for all physical materials in the scene. However,
			 * it's not possible to overwrite an existing texture assigned to the `envMap`
			 * material property.
			 *
			 * @type {?Texture}
			 * @default null
			 */ this.environment = null;
	        /**
			 * A fog instance defining the type of fog that affects everything
			 * rendered in the scene.
			 *
			 * @type {?(Fog|FogExp2)}
			 * @default null
			 */ this.fog = null;
	        /**
			 * Sets the blurriness of the background. Only influences environment maps
			 * assigned to {@link Scene#background}. Valid input is a float between `0`
			 * and `1`.
			 *
			 * @type {number}
			 * @default 0
			 */ this.backgroundBlurriness = 0;
	        /**
			 * Attenuates the color of the background. Only applies to background textures.
			 *
			 * @type {number}
			 * @default 1
			 */ this.backgroundIntensity = 1;
	        /**
			 * The rotation of the background in radians. Only influences environment maps
			 * assigned to {@link Scene#background}.
			 *
			 * @type {Euler}
			 * @default (0,0,0)
			 */ this.backgroundRotation = new Euler();
	        /**
			 * Attenuates the color of the environment. Only influences environment maps
			 * assigned to {@link Scene#environment}.
			 *
			 * @type {number}
			 * @default 1
			 */ this.environmentIntensity = 1;
	        /**
			 * The rotation of the environment map in radians. Only influences physical materials
			 * in the scene when {@link Scene#environment} is used.
			 *
			 * @type {Euler}
			 * @default (0,0,0)
			 */ this.environmentRotation = new Euler();
	        /**
			 * Forces everything in the scene to be rendered with the defined material.
			 *
			 * @type {?Material}
			 * @default null
			 */ this.overrideMaterial = null;
	        if (typeof __THREE_DEVTOOLS__ !== 'undefined') {
	            __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent('observe', {
	                detail: this
	            }));
	        }
	    }
	}
	class InterleavedBuffer {
	    onUploadCallback() {}
	    set needsUpdate(value) {
	        if (value === true) this.version++;
	    }
	    setUsage(value) {
	        this.usage = value;
	        return this;
	    }
	    addUpdateRange(start, count) {
	        this.updateRanges.push({
	            start,
	            count
	        });
	    }
	    clearUpdateRanges() {
	        this.updateRanges.length = 0;
	    }
	    copy(source) {
	        this.array = new source.array.constructor(source.array);
	        this.count = source.count;
	        this.stride = source.stride;
	        this.usage = source.usage;
	        return this;
	    }
	    copyAt(index1, attribute, index2) {
	        index1 *= this.stride;
	        index2 *= attribute.stride;
	        for(let i = 0, l = this.stride; i < l; i++){
	            this.array[index1 + i] = attribute.array[index2 + i];
	        }
	        return this;
	    }
	    set(value, offset = 0) {
	        this.array.set(value, offset);
	        return this;
	    }
	    clone(data) {
	        if (data.arrayBuffers === undefined) {
	            data.arrayBuffers = {};
	        }
	        if (this.array.buffer._uuid === undefined) {
	            this.array.buffer._uuid = generateUUID();
	        }
	        if (data.arrayBuffers[this.array.buffer._uuid] === undefined) {
	            data.arrayBuffers[this.array.buffer._uuid] = this.array.slice(0).buffer;
	        }
	        const array = new this.array.constructor(data.arrayBuffers[this.array.buffer._uuid]);
	        const ib = new this.constructor(array, this.stride);
	        ib.setUsage(this.usage);
	        return ib;
	    }
	    onUpload(callback) {
	        this.onUploadCallback = callback;
	        return this;
	    }
	    toJSON(data) {
	        if (data.arrayBuffers === undefined) {
	            data.arrayBuffers = {};
	        }
	        // generate UUID for array buffer if necessary
	        if (this.array.buffer._uuid === undefined) {
	            this.array.buffer._uuid = generateUUID();
	        }
	        if (data.arrayBuffers[this.array.buffer._uuid] === undefined) {
	            data.arrayBuffers[this.array.buffer._uuid] = Array.from(new Uint32Array(this.array.buffer));
	        }
	        //
	        return {
	            uuid: this.uuid,
	            buffer: this.array.buffer._uuid,
	            type: this.array.constructor.name,
	            stride: this.stride
	        };
	    }
	    constructor(array, stride){
	        this.isInterleavedBuffer = true;
	        this.array = array;
	        this.stride = stride;
	        this.count = array !== undefined ? array.length / stride : 0;
	        this.usage = StaticDrawUsage;
	        this.updateRanges = [];
	        this.version = 0;
	        this.uuid = generateUUID();
	    }
	}
	const _vector$7 = /*@__PURE__*/ new Vector3();
	class InterleavedBufferAttribute {
	    get count() {
	        return this.data.count;
	    }
	    get array() {
	        return this.data.array;
	    }
	    set needsUpdate(value) {
	        this.data.needsUpdate = value;
	    }
	    applyMatrix4(m) {
	        for(let i = 0, l = this.data.count; i < l; i++){
	            _vector$7.fromBufferAttribute(this, i);
	            _vector$7.applyMatrix4(m);
	            this.setXYZ(i, _vector$7.x, _vector$7.y, _vector$7.z);
	        }
	        return this;
	    }
	    applyNormalMatrix(m) {
	        for(let i = 0, l = this.count; i < l; i++){
	            _vector$7.fromBufferAttribute(this, i);
	            _vector$7.applyNormalMatrix(m);
	            this.setXYZ(i, _vector$7.x, _vector$7.y, _vector$7.z);
	        }
	        return this;
	    }
	    transformDirection(m) {
	        for(let i = 0, l = this.count; i < l; i++){
	            _vector$7.fromBufferAttribute(this, i);
	            _vector$7.transformDirection(m);
	            this.setXYZ(i, _vector$7.x, _vector$7.y, _vector$7.z);
	        }
	        return this;
	    }
	    getComponent(index, component) {
	        let value = this.array[index * this.data.stride + this.offset + component];
	        if (this.normalized) value = denormalize(value, this.array);
	        return value;
	    }
	    setComponent(index, component, value) {
	        if (this.normalized) value = normalize(value, this.array);
	        this.data.array[index * this.data.stride + this.offset + component] = value;
	        return this;
	    }
	    setX(index, x) {
	        if (this.normalized) x = normalize(x, this.array);
	        this.data.array[index * this.data.stride + this.offset] = x;
	        return this;
	    }
	    setY(index, y) {
	        if (this.normalized) y = normalize(y, this.array);
	        this.data.array[index * this.data.stride + this.offset + 1] = y;
	        return this;
	    }
	    setZ(index, z) {
	        if (this.normalized) z = normalize(z, this.array);
	        this.data.array[index * this.data.stride + this.offset + 2] = z;
	        return this;
	    }
	    setW(index, w) {
	        if (this.normalized) w = normalize(w, this.array);
	        this.data.array[index * this.data.stride + this.offset + 3] = w;
	        return this;
	    }
	    getX(index) {
	        let x = this.data.array[index * this.data.stride + this.offset];
	        if (this.normalized) x = denormalize(x, this.array);
	        return x;
	    }
	    getY(index) {
	        let y = this.data.array[index * this.data.stride + this.offset + 1];
	        if (this.normalized) y = denormalize(y, this.array);
	        return y;
	    }
	    getZ(index) {
	        let z = this.data.array[index * this.data.stride + this.offset + 2];
	        if (this.normalized) z = denormalize(z, this.array);
	        return z;
	    }
	    getW(index) {
	        let w = this.data.array[index * this.data.stride + this.offset + 3];
	        if (this.normalized) w = denormalize(w, this.array);
	        return w;
	    }
	    setXY(index, x, y) {
	        index = index * this.data.stride + this.offset;
	        if (this.normalized) {
	            x = normalize(x, this.array);
	            y = normalize(y, this.array);
	        }
	        this.data.array[index + 0] = x;
	        this.data.array[index + 1] = y;
	        return this;
	    }
	    setXYZ(index, x, y, z) {
	        index = index * this.data.stride + this.offset;
	        if (this.normalized) {
	            x = normalize(x, this.array);
	            y = normalize(y, this.array);
	            z = normalize(z, this.array);
	        }
	        this.data.array[index + 0] = x;
	        this.data.array[index + 1] = y;
	        this.data.array[index + 2] = z;
	        return this;
	    }
	    setXYZW(index, x, y, z, w) {
	        index = index * this.data.stride + this.offset;
	        if (this.normalized) {
	            x = normalize(x, this.array);
	            y = normalize(y, this.array);
	            z = normalize(z, this.array);
	            w = normalize(w, this.array);
	        }
	        this.data.array[index + 0] = x;
	        this.data.array[index + 1] = y;
	        this.data.array[index + 2] = z;
	        this.data.array[index + 3] = w;
	        return this;
	    }
	    clone(data) {
	        if (data === undefined) {
	            console.log('THREE.InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data.');
	            const array = [];
	            for(let i = 0; i < this.count; i++){
	                const index = i * this.data.stride + this.offset;
	                for(let j = 0; j < this.itemSize; j++){
	                    array.push(this.data.array[index + j]);
	                }
	            }
	            return new BufferAttribute(new this.array.constructor(array), this.itemSize, this.normalized);
	        } else {
	            if (data.interleavedBuffers === undefined) {
	                data.interleavedBuffers = {};
	            }
	            if (data.interleavedBuffers[this.data.uuid] === undefined) {
	                data.interleavedBuffers[this.data.uuid] = this.data.clone(data);
	            }
	            return new InterleavedBufferAttribute(data.interleavedBuffers[this.data.uuid], this.itemSize, this.offset, this.normalized);
	        }
	    }
	    toJSON(data) {
	        if (data === undefined) {
	            console.log('THREE.InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data.');
	            const array = [];
	            for(let i = 0; i < this.count; i++){
	                const index = i * this.data.stride + this.offset;
	                for(let j = 0; j < this.itemSize; j++){
	                    array.push(this.data.array[index + j]);
	                }
	            }
	            // de-interleave data and save it as an ordinary buffer attribute for now
	            return {
	                itemSize: this.itemSize,
	                type: this.array.constructor.name,
	                array: array,
	                normalized: this.normalized
	            };
	        } else {
	            // save as true interleaved attribute
	            if (data.interleavedBuffers === undefined) {
	                data.interleavedBuffers = {};
	            }
	            if (data.interleavedBuffers[this.data.uuid] === undefined) {
	                data.interleavedBuffers[this.data.uuid] = this.data.toJSON(data);
	            }
	            return {
	                isInterleavedBufferAttribute: true,
	                itemSize: this.itemSize,
	                data: this.data.uuid,
	                offset: this.offset,
	                normalized: this.normalized
	            };
	        }
	    }
	    constructor(interleavedBuffer, itemSize, offset, normalized = false){
	        this.isInterleavedBufferAttribute = true;
	        this.name = '';
	        this.data = interleavedBuffer;
	        this.itemSize = itemSize;
	        this.offset = offset;
	        this.normalized = normalized;
	    }
	}
	const _basePosition = /*@__PURE__*/ new Vector3();
	const _skinIndex = /*@__PURE__*/ new Vector4();
	const _skinWeight = /*@__PURE__*/ new Vector4();
	const _vector3 = /*@__PURE__*/ new Vector3();
	const _matrix4 = /*@__PURE__*/ new Matrix4();
	const _vertex = /*@__PURE__*/ new Vector3();
	const _sphere$5 = /*@__PURE__*/ new Sphere();
	const _inverseMatrix$2 = /*@__PURE__*/ new Matrix4();
	const _ray$2 = /*@__PURE__*/ new Ray();
	/**
	 * A mesh that has a {@link Skeleton} that can then be used to animate the
	 * vertices of the geometry with skinning/skeleton animation.
	 *
	 * Next to a valid skeleton, the skinned mesh requires skin indices and weights
	 * as buffer attributes in its geometry. These attribute define which bones affect a single
	 * vertex to a certain extend.
	 *
	 * Typically skinned meshes are not created manually but loaders like {@link GLTFLoader}
	 * or {@link FBXLoader } import respective models.
	 *
	 * @augments Mesh
	 */ class SkinnedMesh extends Mesh {
	    /**
		 * Computes the bounding box of the skinned mesh, and updates {@link SkinnedMesh#boundingBox}.
		 * The bounding box is not automatically computed by the engine; this method must be called by your app.
		 * If the skinned mesh is animated, the bounding box should be recomputed per frame in order to reflect
		 * the current animation state.
		 */ computeBoundingBox() {
	        const geometry = this.geometry;
	        if (this.boundingBox === null) {
	            this.boundingBox = new Box3();
	        }
	        this.boundingBox.makeEmpty();
	        const positionAttribute = geometry.getAttribute('position');
	        for(let i = 0; i < positionAttribute.count; i++){
	            this.getVertexPosition(i, _vertex);
	            this.boundingBox.expandByPoint(_vertex);
	        }
	    }
	    /**
		 * Computes the bounding sphere of the skinned mesh, and updates {@link SkinnedMesh#boundingSphere}.
		 * The bounding sphere is automatically computed by the engine once when it is needed, e.g., for ray casting
		 * and view frustum culling. If the skinned mesh is animated, the bounding sphere should be recomputed
		 * per frame in order to reflect the current animation state.
		 */ computeBoundingSphere() {
	        const geometry = this.geometry;
	        if (this.boundingSphere === null) {
	            this.boundingSphere = new Sphere();
	        }
	        this.boundingSphere.makeEmpty();
	        const positionAttribute = geometry.getAttribute('position');
	        for(let i = 0; i < positionAttribute.count; i++){
	            this.getVertexPosition(i, _vertex);
	            this.boundingSphere.expandByPoint(_vertex);
	        }
	    }
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.bindMode = source.bindMode;
	        this.bindMatrix.copy(source.bindMatrix);
	        this.bindMatrixInverse.copy(source.bindMatrixInverse);
	        this.skeleton = source.skeleton;
	        if (source.boundingBox !== null) this.boundingBox = source.boundingBox.clone();
	        if (source.boundingSphere !== null) this.boundingSphere = source.boundingSphere.clone();
	        return this;
	    }
	    raycast(raycaster, intersects) {
	        const material = this.material;
	        const matrixWorld = this.matrixWorld;
	        if (material === undefined) return;
	        // test with bounding sphere in world space
	        if (this.boundingSphere === null) this.computeBoundingSphere();
	        _sphere$5.copy(this.boundingSphere);
	        _sphere$5.applyMatrix4(matrixWorld);
	        if (raycaster.ray.intersectsSphere(_sphere$5) === false) return;
	        // convert ray to local space of skinned mesh
	        _inverseMatrix$2.copy(matrixWorld).invert();
	        _ray$2.copy(raycaster.ray).applyMatrix4(_inverseMatrix$2);
	        // test with bounding box in local space
	        if (this.boundingBox !== null) {
	            if (_ray$2.intersectsBox(this.boundingBox) === false) return;
	        }
	        // test for intersections with geometry
	        this._computeIntersections(raycaster, intersects, _ray$2);
	    }
	    getVertexPosition(index, target) {
	        super.getVertexPosition(index, target);
	        this.applyBoneTransform(index, target);
	        return target;
	    }
	    /**
		 * Binds the given skeleton to the skinned mesh.
		 *
		 * @param {Skeleton} skeleton - The skeleton to bind.
		 * @param {Matrix4} [bindMatrix] - The bind matrix. If no bind matrix is provided,
		 * the skinned mesh's world matrix will be used instead.
		 */ bind(skeleton, bindMatrix) {
	        this.skeleton = skeleton;
	        if (bindMatrix === undefined) {
	            this.updateMatrixWorld(true);
	            this.skeleton.calculateInverses();
	            bindMatrix = this.matrixWorld;
	        }
	        this.bindMatrix.copy(bindMatrix);
	        this.bindMatrixInverse.copy(bindMatrix).invert();
	    }
	    /**
		 * This method sets the skinned mesh in the rest pose).
		 */ pose() {
	        this.skeleton.pose();
	    }
	    /**
		 * Normalizes the skin weights which are defined as a buffer attribute
		 * in the skinned mesh's geometry.
		 */ normalizeSkinWeights() {
	        const vector = new Vector4();
	        const skinWeight = this.geometry.attributes.skinWeight;
	        for(let i = 0, l = skinWeight.count; i < l; i++){
	            vector.fromBufferAttribute(skinWeight, i);
	            const scale = 1.0 / vector.manhattanLength();
	            if (scale !== Infinity) {
	                vector.multiplyScalar(scale);
	            } else {
	                vector.set(1, 0, 0, 0); // do something reasonable
	            }
	            skinWeight.setXYZW(i, vector.x, vector.y, vector.z, vector.w);
	        }
	    }
	    updateMatrixWorld(force) {
	        super.updateMatrixWorld(force);
	        if (this.bindMode === AttachedBindMode) {
	            this.bindMatrixInverse.copy(this.matrixWorld).invert();
	        } else if (this.bindMode === DetachedBindMode) {
	            this.bindMatrixInverse.copy(this.bindMatrix).invert();
	        } else {
	            console.warn('THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode);
	        }
	    }
	    /**
		 * Applies the bone transform associated with the given index to the given
		 * vertex position. Returns the updated vector.
		 *
		 * @param {number} index - The vertex index.
		 * @param {Vector3} target - The target object that is used to store the method's result.
		 * the skinned mesh's world matrix will be used instead.
		 * @return {Vector3} The updated vertex position.
		 */ applyBoneTransform(index, target) {
	        const skeleton = this.skeleton;
	        const geometry = this.geometry;
	        _skinIndex.fromBufferAttribute(geometry.attributes.skinIndex, index);
	        _skinWeight.fromBufferAttribute(geometry.attributes.skinWeight, index);
	        _basePosition.copy(target).applyMatrix4(this.bindMatrix);
	        target.set(0, 0, 0);
	        for(let i = 0; i < 4; i++){
	            const weight = _skinWeight.getComponent(i);
	            if (weight !== 0) {
	                const boneIndex = _skinIndex.getComponent(i);
	                _matrix4.multiplyMatrices(skeleton.bones[boneIndex].matrixWorld, skeleton.boneInverses[boneIndex]);
	                target.addScaledVector(_vector3.copy(_basePosition).applyMatrix4(_matrix4), weight);
	            }
	        }
	        return target.applyMatrix4(this.bindMatrixInverse);
	    }
	    /**
		 * Constructs a new skinned mesh.
		 *
		 * @param {BufferGeometry} [geometry] - The mesh geometry.
		 * @param {Material|Array<Material>} [material] - The mesh material.
		 */ constructor(geometry, material){
	        super(geometry, material);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isSkinnedMesh = true;
	        this.type = 'SkinnedMesh';
	        /**
			 * `AttachedBindMode` means the skinned mesh shares the same world space as the skeleton.
			 * This is not true when using `DetachedBindMode` which is useful when sharing a skeleton
			 * across multiple skinned meshes.
			 *
			 * @type {(AttachedBindMode|DetachedBindMode)}
			 * @default AttachedBindMode
			 */ this.bindMode = AttachedBindMode;
	        /**
			 * The base matrix that is used for the bound bone transforms.
			 *
			 * @type {Matrix4}
			 */ this.bindMatrix = new Matrix4();
	        /**
			 * The base matrix that is used for resetting the bound bone transforms.
			 *
			 * @type {Matrix4}
			 */ this.bindMatrixInverse = new Matrix4();
	        /**
			 * The bounding box of the skinned mesh. Can be computed via {@link SkinnedMesh#computeBoundingBox}.
			 *
			 * @type {?Box3}
			 * @default null
			 */ this.boundingBox = null;
	        /**
			 * The bounding sphere of the skinned mesh. Can be computed via {@link SkinnedMesh#computeBoundingSphere}.
			 *
			 * @type {?Sphere}
			 * @default null
			 */ this.boundingSphere = null;
	    }
	}
	/**
	 * A bone which is part of a {@link Skeleton}. The skeleton in turn is used by
	 * the {@link SkinnedMesh}.
	 *
	 * ```js
	 * const root = new THREE.Bone();
	 * const child = new THREE.Bone();
	 *
	 * root.add( child );
	 * child.position.y = 5;
	 * ```
	 *
	 * @augments Object3D
	 */ class Bone extends Object3D {
	    /**
		 * Constructs a new bone.
		 */ constructor(){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isBone = true;
	        this.type = 'Bone';
	    }
	}
	class DataTexture extends Texture$1 {
	    constructor(data = null, width = 1, height = 1, format, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace){
	        super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
	        this.isDataTexture = true;
	        this.image = {
	            data: data,
	            width: width,
	            height: height
	        };
	        this.generateMipmaps = false;
	        this.flipY = false;
	        this.unpackAlignment = 1;
	    }
	}
	const _offsetMatrix = /*@__PURE__*/ new Matrix4();
	const _identityMatrix$1 = /*@__PURE__*/ new Matrix4();
	/**
	 * Class for representing the armatures in `three.js`. The skeleton
	 * is defined by a hierarchy of bones.
	 *
	 * ```js
	 * const bones = [];
	 *
	 * const shoulder = new THREE.Bone();
	 * const elbow = new THREE.Bone();
	 * const hand = new THREE.Bone();
	 *
	 * shoulder.add( elbow );
	 * elbow.add( hand );
	 *
	 * bones.push( shoulder , elbow, hand);
	 *
	 * shoulder.position.y = -5;
	 * elbow.position.y = 0;
	 * hand.position.y = 5;
	 *
	 * const armSkeleton = new THREE.Skeleton( bones );
	 * ```
	 */ class Skeleton {
	    /**
		 * Initializes the skeleton. This method gets automatically called by the constructor
		 * but depending on how the skeleton is created it might be necessary to call this method
		 * manually.
		 */ init() {
	        const bones = this.bones;
	        const boneInverses = this.boneInverses;
	        this.boneMatrices = new Float32Array(bones.length * 16);
	        // calculate inverse bone matrices if necessary
	        if (boneInverses.length === 0) {
	            this.calculateInverses();
	        } else {
	            // handle special case
	            if (bones.length !== boneInverses.length) {
	                console.warn('THREE.Skeleton: Number of inverse bone matrices does not match amount of bones.');
	                this.boneInverses = [];
	                for(let i = 0, il = this.bones.length; i < il; i++){
	                    this.boneInverses.push(new Matrix4());
	                }
	            }
	        }
	    }
	    /**
		 * Computes the bone inverse matrices. This method resets {@link Skeleton#boneInverses}
		 * and fills it with new matrices.
		 */ calculateInverses() {
	        this.boneInverses.length = 0;
	        for(let i = 0, il = this.bones.length; i < il; i++){
	            const inverse = new Matrix4();
	            if (this.bones[i]) {
	                inverse.copy(this.bones[i].matrixWorld).invert();
	            }
	            this.boneInverses.push(inverse);
	        }
	    }
	    /**
		 * Resets the skeleton to the base pose.
		 */ pose() {
	        // recover the bind-time world matrices
	        for(let i = 0, il = this.bones.length; i < il; i++){
	            const bone = this.bones[i];
	            if (bone) {
	                bone.matrixWorld.copy(this.boneInverses[i]).invert();
	            }
	        }
	        // compute the local matrices, positions, rotations and scales
	        for(let i = 0, il = this.bones.length; i < il; i++){
	            const bone = this.bones[i];
	            if (bone) {
	                if (bone.parent && bone.parent.isBone) {
	                    bone.matrix.copy(bone.parent.matrixWorld).invert();
	                    bone.matrix.multiply(bone.matrixWorld);
	                } else {
	                    bone.matrix.copy(bone.matrixWorld);
	                }
	                bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
	            }
	        }
	    }
	    /**
		 * Resets the skeleton to the base pose.
		 */ update() {
	        const bones = this.bones;
	        const boneInverses = this.boneInverses;
	        const boneMatrices = this.boneMatrices;
	        const boneTexture = this.boneTexture;
	        // flatten bone matrices to array
	        for(let i = 0, il = bones.length; i < il; i++){
	            // compute the offset between the current and the original transform
	            const matrix = bones[i] ? bones[i].matrixWorld : _identityMatrix$1;
	            _offsetMatrix.multiplyMatrices(matrix, boneInverses[i]);
	            _offsetMatrix.toArray(boneMatrices, i * 16);
	        }
	        if (boneTexture !== null) {
	            boneTexture.needsUpdate = true;
	        }
	    }
	    /**
		 * Returns a new skeleton with copied values from this instance.
		 *
		 * @return {Skeleton} A clone of this instance.
		 */ clone() {
	        return new Skeleton(this.bones, this.boneInverses);
	    }
	    /**
		 * Computes a data texture for passing bone data to the vertex shader.
		 *
		 * @return {Skeleton} A reference of this instance.
		 */ computeBoneTexture() {
	        // layout (1 matrix = 4 pixels)
	        //      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
	        //  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)
	        //       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)
	        //       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)
	        //       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)
	        let size = Math.sqrt(this.bones.length * 4); // 4 pixels needed for 1 matrix
	        size = Math.ceil(size / 4) * 4;
	        size = Math.max(size, 4);
	        const boneMatrices = new Float32Array(size * size * 4); // 4 floats per RGBA pixel
	        boneMatrices.set(this.boneMatrices); // copy current values
	        const boneTexture = new DataTexture(boneMatrices, size, size, RGBAFormat, FloatType);
	        boneTexture.needsUpdate = true;
	        this.boneMatrices = boneMatrices;
	        this.boneTexture = boneTexture;
	        return this;
	    }
	    /**
		 * Searches through the skeleton's bone array and returns the first with a
		 * matching name.
		 *
		 * @param {string} name - The name of the bone.
		 * @return {Bone|undefined} The found bone. `undefined` if no bone has been found.
		 */ getBoneByName(name) {
	        for(let i = 0, il = this.bones.length; i < il; i++){
	            const bone = this.bones[i];
	            if (bone.name === name) {
	                return bone;
	            }
	        }
	        return undefined;
	    }
	    /**
		 * Frees the GPU-related resources allocated by this instance. Call this
		 * method whenever this instance is no longer used in your app.
		 */ dispose() {
	        if (this.boneTexture !== null) {
	            this.boneTexture.dispose();
	            this.boneTexture = null;
	        }
	    }
	    /**
		 * Setups the skeleton by the given JSON and bones.
		 *
		 * @param {Object} json - The skeleton as serialized JSON.
		 * @param {Array<Bone>} bones - An array of bones.
		 * @return {Skeleton} A reference of this instance.
		 */ fromJSON(json, bones) {
	        this.uuid = json.uuid;
	        for(let i = 0, l = json.bones.length; i < l; i++){
	            const uuid = json.bones[i];
	            let bone = bones[uuid];
	            if (bone === undefined) {
	                console.warn('THREE.Skeleton: No bone found with UUID:', uuid);
	                bone = new Bone();
	            }
	            this.bones.push(bone);
	            this.boneInverses.push(new Matrix4().fromArray(json.boneInverses[i]));
	        }
	        this.init();
	        return this;
	    }
	    /**
		 * Serializes the skeleton into JSON.
		 *
		 * @return {Object} A JSON object representing the serialized skeleton.
		 * @see {@link ObjectLoader#parse}
		 */ toJSON() {
	        const data = {
	            metadata: {
	                version: 4.6,
	                type: 'Skeleton',
	                generator: 'Skeleton.toJSON'
	            },
	            bones: [],
	            boneInverses: []
	        };
	        data.uuid = this.uuid;
	        const bones = this.bones;
	        const boneInverses = this.boneInverses;
	        for(let i = 0, l = bones.length; i < l; i++){
	            const bone = bones[i];
	            data.bones.push(bone.uuid);
	            const boneInverse = boneInverses[i];
	            data.boneInverses.push(boneInverse.toArray());
	        }
	        return data;
	    }
	    /**
		 * Constructs a new skeleton.
		 *
		 * @param {Array<Bone>} [bones] - An array of bones.
		 * @param {Array<Matrix4>} [boneInverses] - An array of bone inverse matrices.
		 * If not provided, these matrices will be computed automatically via {@link Skeleton#calculateInverses}.
		 */ constructor(bones = [], boneInverses = []){
	        this.uuid = generateUUID();
	        /**
			 * An array of bones defining the skeleton.
			 *
			 * @type {Array<Bone>}
			 */ this.bones = bones.slice(0);
	        /**
			 * An array of bone inverse matrices.
			 *
			 * @type {Array<Matrix4>}
			 */ this.boneInverses = boneInverses;
	        /**
			 * An array buffer holding the bone data.
			 * Input data for {@link Skeleton#boneTexture}.
			 *
			 * @type {?Float32Array}
			 * @default null
			 */ this.boneMatrices = null;
	        /**
			 * A texture holding the bone data for use
			 * in the vertex shader.
			 *
			 * @type {?DataTexture}
			 * @default null
			 */ this.boneTexture = null;
	        this.init();
	    }
	}
	class InstancedBufferAttribute extends BufferAttribute {
	    copy(source) {
	        super.copy(source);
	        this.meshPerAttribute = source.meshPerAttribute;
	        return this;
	    }
	    toJSON() {
	        const data = super.toJSON();
	        data.meshPerAttribute = this.meshPerAttribute;
	        data.isInstancedBufferAttribute = true;
	        return data;
	    }
	    constructor(array, itemSize, normalized, meshPerAttribute = 1){
	        super(array, itemSize, normalized);
	        this.isInstancedBufferAttribute = true;
	        this.meshPerAttribute = meshPerAttribute;
	    }
	}
	const _instanceLocalMatrix = /*@__PURE__*/ new Matrix4();
	const _instanceWorldMatrix = /*@__PURE__*/ new Matrix4();
	const _instanceIntersects = [];
	const _box3 = /*@__PURE__*/ new Box3();
	const _identity = /*@__PURE__*/ new Matrix4();
	const _mesh$1 = /*@__PURE__*/ new Mesh();
	const _sphere$4 = /*@__PURE__*/ new Sphere();
	/**
	 * A special version of a mesh with instanced rendering support. Use
	 * this class if you have to render a large number of objects with the same
	 * geometry and material(s) but with different world transformations. The usage
	 * of 'InstancedMesh' will help you to reduce the number of draw calls and thus
	 * improve the overall rendering performance in your application.
	 *
	 * @augments Mesh
	 */ class InstancedMesh extends Mesh {
	    /**
		 * Computes the bounding box of the instanced mesh, and updates {@link InstancedMesh#boundingBox}.
		 * The bounding box is not automatically computed by the engine; this method must be called by your app.
		 * You may need to recompute the bounding box if an instance is transformed via {@link InstancedMesh#setMatrixAt}.
		 */ computeBoundingBox() {
	        const geometry = this.geometry;
	        const count = this.count;
	        if (this.boundingBox === null) {
	            this.boundingBox = new Box3();
	        }
	        if (geometry.boundingBox === null) {
	            geometry.computeBoundingBox();
	        }
	        this.boundingBox.makeEmpty();
	        for(let i = 0; i < count; i++){
	            this.getMatrixAt(i, _instanceLocalMatrix);
	            _box3.copy(geometry.boundingBox).applyMatrix4(_instanceLocalMatrix);
	            this.boundingBox.union(_box3);
	        }
	    }
	    /**
		 * Computes the bounding sphere of the instanced mesh, and updates {@link InstancedMesh#boundingSphere}
		 * The engine automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling.
		 * You may need to recompute the bounding sphere if an instance is transformed via {@link InstancedMesh#setMatrixAt}.
		 */ computeBoundingSphere() {
	        const geometry = this.geometry;
	        const count = this.count;
	        if (this.boundingSphere === null) {
	            this.boundingSphere = new Sphere();
	        }
	        if (geometry.boundingSphere === null) {
	            geometry.computeBoundingSphere();
	        }
	        this.boundingSphere.makeEmpty();
	        for(let i = 0; i < count; i++){
	            this.getMatrixAt(i, _instanceLocalMatrix);
	            _sphere$4.copy(geometry.boundingSphere).applyMatrix4(_instanceLocalMatrix);
	            this.boundingSphere.union(_sphere$4);
	        }
	    }
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.instanceMatrix.copy(source.instanceMatrix);
	        if (source.morphTexture !== null) this.morphTexture = source.morphTexture.clone();
	        if (source.instanceColor !== null) this.instanceColor = source.instanceColor.clone();
	        this.count = source.count;
	        if (source.boundingBox !== null) this.boundingBox = source.boundingBox.clone();
	        if (source.boundingSphere !== null) this.boundingSphere = source.boundingSphere.clone();
	        return this;
	    }
	    /**
		 * Gets the color of the defined instance.
		 *
		 * @param {number} index - The instance index.
		 * @param {Color} color - The target object that is used to store the method's result.
		 */ getColorAt(index, color) {
	        color.fromArray(this.instanceColor.array, index * 3);
	    }
	    /**
		 * Gets the local transformation matrix of the defined instance.
		 *
		 * @param {number} index - The instance index.
		 * @param {Matrix4} matrix - The target object that is used to store the method's result.
		 */ getMatrixAt(index, matrix) {
	        matrix.fromArray(this.instanceMatrix.array, index * 16);
	    }
	    /**
		 * Gets the morph target weights of the defined instance.
		 *
		 * @param {number} index - The instance index.
		 * @param {Mesh} object - The target object that is used to store the method's result.
		 */ getMorphAt(index, object) {
	        const objectInfluences = object.morphTargetInfluences;
	        const array = this.morphTexture.source.data.data;
	        const len = objectInfluences.length + 1; // All influences + the baseInfluenceSum
	        const dataIndex = index * len + 1; // Skip the baseInfluenceSum at the beginning
	        for(let i = 0; i < objectInfluences.length; i++){
	            objectInfluences[i] = array[dataIndex + i];
	        }
	    }
	    raycast(raycaster, intersects) {
	        const matrixWorld = this.matrixWorld;
	        const raycastTimes = this.count;
	        _mesh$1.geometry = this.geometry;
	        _mesh$1.material = this.material;
	        if (_mesh$1.material === undefined) return;
	        // test with bounding sphere first
	        if (this.boundingSphere === null) this.computeBoundingSphere();
	        _sphere$4.copy(this.boundingSphere);
	        _sphere$4.applyMatrix4(matrixWorld);
	        if (raycaster.ray.intersectsSphere(_sphere$4) === false) return;
	        // now test each instance
	        for(let instanceId = 0; instanceId < raycastTimes; instanceId++){
	            // calculate the world matrix for each instance
	            this.getMatrixAt(instanceId, _instanceLocalMatrix);
	            _instanceWorldMatrix.multiplyMatrices(matrixWorld, _instanceLocalMatrix);
	            // the mesh represents this single instance
	            _mesh$1.matrixWorld = _instanceWorldMatrix;
	            _mesh$1.raycast(raycaster, _instanceIntersects);
	            // process the result of raycast
	            for(let i = 0, l = _instanceIntersects.length; i < l; i++){
	                const intersect = _instanceIntersects[i];
	                intersect.instanceId = instanceId;
	                intersect.object = this;
	                intersects.push(intersect);
	            }
	            _instanceIntersects.length = 0;
	        }
	    }
	    /**
		 * Sets the given color to the defined instance. Make sure you set the `needsUpdate` flag of
		 * {@link InstancedMesh#instanceColor} to `true` after updating all the colors.
		 *
		 * @param {number} index - The instance index.
		 * @param {Color} color - The instance color.
		 */ setColorAt(index, color) {
	        if (this.instanceColor === null) {
	            this.instanceColor = new InstancedBufferAttribute(new Float32Array(this.instanceMatrix.count * 3).fill(1), 3);
	        }
	        color.toArray(this.instanceColor.array, index * 3);
	    }
	    /**
		 * Sets the given local transformation matrix to the defined instance. Make sure you set the `needsUpdate` flag of
		 * {@link InstancedMesh#instanceMatrix} to `true` after updating all the colors.
		 *
		 * @param {number} index - The instance index.
		 * @param {Matrix4} matrix - The the local transformation.
		 */ setMatrixAt(index, matrix) {
	        matrix.toArray(this.instanceMatrix.array, index * 16);
	    }
	    /**
		 * Sets the morph target weights to the defined instance. Make sure you set the `needsUpdate` flag of
		 * {@link InstancedMesh#morphTexture} to `true` after updating all the influences.
		 *
		 * @param {number} index - The instance index.
		 * @param {Mesh} object -  A mesh which `morphTargetInfluences` property containing the morph target weights
		 * of a single instance.
		 */ setMorphAt(index, object) {
	        const objectInfluences = object.morphTargetInfluences;
	        const len = objectInfluences.length + 1; // morphBaseInfluence + all influences
	        if (this.morphTexture === null) {
	            this.morphTexture = new DataTexture(new Float32Array(len * this.count), len, this.count, RedFormat, FloatType);
	        }
	        const array = this.morphTexture.source.data.data;
	        let morphInfluencesSum = 0;
	        for(let i = 0; i < objectInfluences.length; i++){
	            morphInfluencesSum += objectInfluences[i];
	        }
	        const morphBaseInfluence = this.geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;
	        const dataIndex = len * index;
	        array[dataIndex] = morphBaseInfluence;
	        array.set(objectInfluences, dataIndex + 1);
	    }
	    updateMorphTargets() {}
	    /**
		 * Frees the GPU-related resources allocated by this instance. Call this
		 * method whenever this instance is no longer used in your app.
		 */ dispose() {
	        this.dispatchEvent({
	            type: 'dispose'
	        });
	        if (this.morphTexture !== null) {
	            this.morphTexture.dispose();
	            this.morphTexture = null;
	        }
	    }
	    /**
		 * Constructs a new instanced mesh.
		 *
		 * @param {BufferGeometry} [geometry] - The mesh geometry.
		 * @param {Material|Array<Material>} [material] - The mesh material.
		 * @param {number} count - The number of instances.
		 */ constructor(geometry, material, count){
	        super(geometry, material);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isInstancedMesh = true;
	        /**
			 * Represents the local transformation of all instances. You have to set its
			 * {@link BufferAttribute#needsUpdate} flag to true if you modify instanced data
			 * via {@link InstancedMesh#setMatrixAt}.
			 *
			 * @type {InstancedBufferAttribute}
			 */ this.instanceMatrix = new InstancedBufferAttribute(new Float32Array(count * 16), 16);
	        /**
			 * Represents the color of all instances. You have to set its
			 * {@link BufferAttribute#needsUpdate} flag to true if you modify instanced data
			 * via {@link InstancedMesh#setColorAt}.
			 *
			 * @type {?InstancedBufferAttribute}
			 * @default null
			 */ this.instanceColor = null;
	        /**
			 * Represents the morph target weights of all instances. You have to set its
			 * {@link Texture#needsUpdate} flag to true if you modify instanced data
			 * via {@link InstancedMesh#setMorphAt}.
			 *
			 * @type {?InstancedBufferAttribute}
			 * @default null
			 */ this.morphTexture = null;
	        /**
			 * The number of instances.
			 *
			 * @type {number}
			 */ this.count = count;
	        /**
			 * The bounding box of the instanced mesh. Can be computed via {@link InstancedMesh#computeBoundingBox}.
			 *
			 * @type {?Box3}
			 * @default null
			 */ this.boundingBox = null;
	        /**
			 * The bounding sphere of the instanced mesh. Can be computed via {@link InstancedMesh#computeBoundingSphere}.
			 *
			 * @type {?Sphere}
			 * @default null
			 */ this.boundingSphere = null;
	        for(let i = 0; i < count; i++){
	            this.setMatrixAt(i, _identity);
	        }
	    }
	}
	const _vector1 = /*@__PURE__*/ new Vector3();
	const _vector2 = /*@__PURE__*/ new Vector3();
	const _normalMatrix = /*@__PURE__*/ new Matrix3();
	/**
	 * A two dimensional surface that extends infinitely in 3D space, represented
	 * in [Hessian normal form]{@link http://mathworld.wolfram.com/HessianNormalForm.html}
	 * by a unit length normal vector and a constant.
	 */ class Plane {
	    /**
		 * Sets the plane components by copying the given values.
		 *
		 * @param {Vector3} normal - The normal.
		 * @param {number} constant - The constant.
		 * @return {Plane} A reference to this plane.
		 */ set(normal, constant) {
	        this.normal.copy(normal);
	        this.constant = constant;
	        return this;
	    }
	    /**
		 * Sets the plane components by defining `x`, `y`, `z` as the
		 * plane normal and `w` as the constant.
		 *
		 * @param {number} x - The value for the normal's x component.
		 * @param {number} y - The value for the normal's y component.
		 * @param {number} z - The value for the normal's z component.
		 * @param {number} w - The constant value.
		 * @return {Plane} A reference to this plane.
		 */ setComponents(x, y, z, w) {
	        this.normal.set(x, y, z);
	        this.constant = w;
	        return this;
	    }
	    /**
		 * Sets the plane from the given normal and coplanar point (that is a point
		 * that lies onto the plane).
		 *
		 * @param {Vector3} normal - The normal.
		 * @param {Vector3} point - A coplanar point.
		 * @return {Plane} A reference to this plane.
		 */ setFromNormalAndCoplanarPoint(normal, point) {
	        this.normal.copy(normal);
	        this.constant = -point.dot(this.normal);
	        return this;
	    }
	    /**
		 * Sets the plane from three coplanar points. The winding order is
		 * assumed to be counter-clockwise, and determines the direction of
		 * the plane normal.
		 *
		 * @param {Vector3} a - The first coplanar point.
		 * @param {Vector3} b - The second coplanar point.
		 * @param {Vector3} c - The third coplanar point.
		 * @return {Plane} A reference to this plane.
		 */ setFromCoplanarPoints(a, b, c) {
	        const normal = _vector1.subVectors(c, b).cross(_vector2.subVectors(a, b)).normalize();
	        // Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
	        this.setFromNormalAndCoplanarPoint(normal, a);
	        return this;
	    }
	    /**
		 * Copies the values of the given plane to this instance.
		 *
		 * @param {Plane} plane - The plane to copy.
		 * @return {Plane} A reference to this plane.
		 */ copy(plane) {
	        this.normal.copy(plane.normal);
	        this.constant = plane.constant;
	        return this;
	    }
	    /**
		 * Normalizes the plane normal and adjusts the constant accordingly.
		 *
		 * @return {Plane} A reference to this plane.
		 */ 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;
	    }
	    /**
		 * Negates both the plane normal and the constant.
		 *
		 * @return {Plane} A reference to this plane.
		 */ negate() {
	        this.constant *= -1;
	        this.normal.negate();
	        return this;
	    }
	    /**
		 * Returns the signed distance from the given point to this plane.
		 *
		 * @param {Vector3} point - The point to compute the distance for.
		 * @return {number} The signed distance.
		 */ distanceToPoint(point) {
	        return this.normal.dot(point) + this.constant;
	    }
	    /**
		 * Returns the signed distance from the given sphere to this plane.
		 *
		 * @param {Sphere} sphere - The sphere to compute the distance for.
		 * @return {number} The signed distance.
		 */ distanceToSphere(sphere) {
	        return this.distanceToPoint(sphere.center) - sphere.radius;
	    }
	    /**
		 * Projects a the given point onto the plane.
		 *
		 * @param {Vector3} point - The point to project.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The projected point on the plane.
		 */ projectPoint(point, target) {
	        return target.copy(point).addScaledVector(this.normal, -this.distanceToPoint(point));
	    }
	    /**
		 * Returns the intersection point of the passed line and the plane. Returns
		 * `null` if the line does not intersect. Returns the line's starting point if
		 * the line is coplanar with the plane.
		 *
		 * @param {Line3} line - The line to compute the intersection for.
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {?Vector3} The intersection point.
		 */ intersectLine(line, target) {
	        const direction = line.delta(_vector1);
	        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(line.start).addScaledVector(direction, t);
	    }
	    /**
		 * Returns `true` if the given line segment intersects with (passes through) the plane.
		 *
		 * @param {Line3} line - The line to test.
		 * @return {boolean} Whether the given line segment intersects with the plane or not.
		 */ 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;
	    }
	    /**
		 * Returns `true` if the given bounding box intersects with the plane.
		 *
		 * @param {Box3} box - The bounding box to test.
		 * @return {boolean} Whether the given bounding box intersects with the plane or not.
		 */ intersectsBox(box) {
	        return box.intersectsPlane(this);
	    }
	    /**
		 * Returns `true` if the given bounding sphere intersects with the plane.
		 *
		 * @param {Sphere} sphere - The bounding sphere to test.
		 * @return {boolean} Whether the given bounding sphere intersects with the plane or not.
		 */ intersectsSphere(sphere) {
	        return sphere.intersectsPlane(this);
	    }
	    /**
		 * Returns a coplanar vector to the plane, by calculating the
		 * projection of the normal at the origin onto the plane.
		 *
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The coplanar point.
		 */ coplanarPoint(target) {
	        return target.copy(this.normal).multiplyScalar(-this.constant);
	    }
	    /**
		 * Apply a 4x4 matrix to the plane. The matrix must be an affine, homogeneous transform.
		 *
		 * The optional normal matrix can be pre-computed like so:
		 * ```js
		 * const optionalNormalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
		 * ```
		 *
		 * @param {Matrix4} matrix - The transformation matrix.
		 * @param {Matrix4} [optionalNormalMatrix] - A pre-computed normal matrix.
		 * @return {Plane} A reference to this plane.
		 */ applyMatrix4(matrix, optionalNormalMatrix) {
	        const normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix(matrix);
	        const referencePoint = this.coplanarPoint(_vector1).applyMatrix4(matrix);
	        const normal = this.normal.applyMatrix3(normalMatrix).normalize();
	        this.constant = -referencePoint.dot(normal);
	        return this;
	    }
	    /**
		 * Translates the plane by the distance defined by the given offset vector.
		 * Note that this only affects the plane constant and will not affect the normal vector.
		 *
		 * @param {Vector3} offset - The offset vector.
		 * @return {Plane} A reference to this plane.
		 */ translate(offset) {
	        this.constant -= offset.dot(this.normal);
	        return this;
	    }
	    /**
		 * Returns `true` if this plane is equal with the given one.
		 *
		 * @param {Plane} plane - The plane to test for equality.
		 * @return {boolean} Whether this plane is equal with the given one.
		 */ equals(plane) {
	        return plane.normal.equals(this.normal) && plane.constant === this.constant;
	    }
	    /**
		 * Returns a new plane with copied values from this instance.
		 *
		 * @return {Plane} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Constructs a new plane.
		 *
		 * @param {Vector3} [normal=(1,0,0)] - A unit length vector defining the normal of the plane.
		 * @param {number} [constant=0] - The signed distance from the origin to the plane.
		 */ constructor(normal = new Vector3(1, 0, 0), constant = 0){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isPlane = true;
	        /**
			 * A unit length vector defining the normal of the plane.
			 *
			 * @type {Vector3}
			 */ this.normal = normal;
	        /**
			 * The signed distance from the origin to the plane.
			 *
			 * @type {number}
			 * @default 0
			 */ this.constant = constant;
	    }
	}
	const _sphere$3 = /*@__PURE__*/ new Sphere();
	const _vector$6 = /*@__PURE__*/ new Vector3();
	/**
	 * Frustums are used to determine what is inside the camera's field of view.
	 * They help speed up the rendering process - objects which lie outside a camera's
	 * frustum can safely be excluded from rendering.
	 *
	 * This class is mainly intended for use internally by a renderer.
	 */ class Frustum {
	    /**
		 * Sets the frustum planes by copying the given planes.
		 *
		 * @param {Plane} [p0] - The first plane that encloses the frustum.
		 * @param {Plane} [p1] - The second plane that encloses the frustum.
		 * @param {Plane} [p2] - The third plane that encloses the frustum.
		 * @param {Plane} [p3] - The fourth plane that encloses the frustum.
		 * @param {Plane} [p4] - The fifth plane that encloses the frustum.
		 * @param {Plane} [p5] - The sixth plane that encloses the frustum.
		 * @return {Frustum} A reference to this frustum.
		 */ set(p0, p1, p2, p3, p4, p5) {
	        const planes = this.planes;
	        planes[0].copy(p0);
	        planes[1].copy(p1);
	        planes[2].copy(p2);
	        planes[3].copy(p3);
	        planes[4].copy(p4);
	        planes[5].copy(p5);
	        return this;
	    }
	    /**
		 * Copies the values of the given frustum to this instance.
		 *
		 * @param {Frustum} frustum - The frustum to copy.
		 * @return {Frustum} A reference to this frustum.
		 */ copy(frustum) {
	        const planes = this.planes;
	        for(let i = 0; i < 6; i++){
	            planes[i].copy(frustum.planes[i]);
	        }
	        return this;
	    }
	    /**
		 * Sets the frustum planes from the given projection matrix.
		 *
		 * @param {Matrix4} m - The projection matrix.
		 * @param {(WebGLCoordinateSystem|WebGPUCoordinateSystem)} coordinateSystem - The coordinate system.
		 * @return {Frustum} A reference to this frustum.
		 */ setFromProjectionMatrix(m, coordinateSystem = WebGLCoordinateSystem) {
	        const planes = this.planes;
	        const me = m.elements;
	        const me0 = me[0], me1 = me[1], me2 = me[2], me3 = me[3];
	        const me4 = me[4], me5 = me[5], me6 = me[6], me7 = me[7];
	        const me8 = me[8], me9 = me[9], me10 = me[10], me11 = me[11];
	        const me12 = me[12], me13 = me[13], me14 = me[14], me15 = me[15];
	        planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize();
	        planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize();
	        planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize();
	        planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize();
	        planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize();
	        if (coordinateSystem === WebGLCoordinateSystem) {
	            planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize();
	        } else if (coordinateSystem === WebGPUCoordinateSystem) {
	            planes[5].setComponents(me2, me6, me10, me14).normalize();
	        } else {
	            throw new Error('THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: ' + coordinateSystem);
	        }
	        return this;
	    }
	    /**
		 * Returns `true` if the 3D object's bounding sphere is intersecting this frustum.
		 *
		 * Note that the 3D object must have a geometry so that the bounding sphere can be calculated.
		 *
		 * @param {Object3D} object - The 3D object to test.
		 * @return {boolean} Whether the 3D object's bounding sphere is intersecting this frustum or not.
		 */ intersectsObject(object) {
	        if (object.boundingSphere !== undefined) {
	            if (object.boundingSphere === null) object.computeBoundingSphere();
	            _sphere$3.copy(object.boundingSphere).applyMatrix4(object.matrixWorld);
	        } else {
	            const geometry = object.geometry;
	            if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
	            _sphere$3.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld);
	        }
	        return this.intersectsSphere(_sphere$3);
	    }
	    /**
		 * Returns `true` if the given sprite is intersecting this frustum.
		 *
		 * @param {Sprite} sprite - The sprite to test.
		 * @return {boolean} Whether the sprite is intersecting this frustum or not.
		 */ intersectsSprite(sprite) {
	        _sphere$3.center.set(0, 0, 0);
	        _sphere$3.radius = 0.7071067811865476;
	        _sphere$3.applyMatrix4(sprite.matrixWorld);
	        return this.intersectsSphere(_sphere$3);
	    }
	    /**
		 * Returns `true` if the given bounding sphere is intersecting this frustum.
		 *
		 * @param {Sphere} sphere - The bounding sphere to test.
		 * @return {boolean} Whether the bounding sphere is intersecting this frustum or not.
		 */ intersectsSphere(sphere) {
	        const planes = this.planes;
	        const center = sphere.center;
	        const negRadius = -sphere.radius;
	        for(let i = 0; i < 6; i++){
	            const distance = planes[i].distanceToPoint(center);
	            if (distance < negRadius) {
	                return false;
	            }
	        }
	        return true;
	    }
	    /**
		 * Returns `true` if the given bounding box is intersecting this frustum.
		 *
		 * @param {Box3} box - The bounding box to test.
		 * @return {boolean} Whether the bounding box is intersecting this frustum or not.
		 */ intersectsBox(box) {
	        const planes = this.planes;
	        for(let i = 0; i < 6; i++){
	            const plane = planes[i];
	            // corner at max distance
	            _vector$6.x = plane.normal.x > 0 ? box.max.x : box.min.x;
	            _vector$6.y = plane.normal.y > 0 ? box.max.y : box.min.y;
	            _vector$6.z = plane.normal.z > 0 ? box.max.z : box.min.z;
	            if (plane.distanceToPoint(_vector$6) < 0) {
	                return false;
	            }
	        }
	        return true;
	    }
	    /**
		 * Returns `true` if the given point lies within the frustum.
		 *
		 * @param {Vector3} point - The point to test.
		 * @return {boolean} Whether the point lies within this frustum or not.
		 */ containsPoint(point) {
	        const planes = this.planes;
	        for(let i = 0; i < 6; i++){
	            if (planes[i].distanceToPoint(point) < 0) {
	                return false;
	            }
	        }
	        return true;
	    }
	    /**
		 * Returns a new frustum with copied values from this instance.
		 *
		 * @return {Frustum} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Constructs a new frustum.
		 *
		 * @param {Plane} [p0] - The first plane that encloses the frustum.
		 * @param {Plane} [p1] - The second plane that encloses the frustum.
		 * @param {Plane} [p2] - The third plane that encloses the frustum.
		 * @param {Plane} [p3] - The fourth plane that encloses the frustum.
		 * @param {Plane} [p4] - The fifth plane that encloses the frustum.
		 * @param {Plane} [p5] - The sixth plane that encloses the frustum.
		 */ constructor(p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane()){
	        /**
			 * This array holds the planes that enclose the frustum.
			 *
			 * @type {Array<Plane>}
			 */ this.planes = [
	            p0,
	            p1,
	            p2,
	            p3,
	            p4,
	            p5
	        ];
	    }
	}
	class LineBasicMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.color.copy(source.color);
	        this.map = source.map;
	        this.linewidth = source.linewidth;
	        this.linecap = source.linecap;
	        this.linejoin = source.linejoin;
	        this.fog = source.fog;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isLineBasicMaterial = true;
	        this.type = 'LineBasicMaterial';
	        this.color = new Color(0xffffff);
	        this.map = null;
	        this.linewidth = 1;
	        this.linecap = 'round';
	        this.linejoin = 'round';
	        this.fog = true;
	        this.setValues(parameters);
	    }
	}
	const _vStart = /*@__PURE__*/ new Vector3();
	const _vEnd = /*@__PURE__*/ new Vector3();
	const _inverseMatrix$1 = /*@__PURE__*/ new Matrix4();
	const _ray$1 = /*@__PURE__*/ new Ray();
	const _sphere$1 = /*@__PURE__*/ new Sphere();
	const _intersectPointOnRay = /*@__PURE__*/ new Vector3();
	const _intersectPointOnSegment = /*@__PURE__*/ new Vector3();
	/**
	 * A continuous line. The line are rendered by connecting consecutive
	 * vertices with straight lines.
	 *
	 * ```js
	 * const material = new THREE.LineBasicMaterial( { color: 0x0000ff } );
	 *
	 * const points = [];
	 * points.push( new THREE.Vector3( - 10, 0, 0 ) );
	 * points.push( new THREE.Vector3( 0, 10, 0 ) );
	 * points.push( new THREE.Vector3( 10, 0, 0 ) );
	 *
	 * const geometry = new THREE.BufferGeometry().setFromPoints( points );
	 *
	 * const line = new THREE.Line( geometry, material );
	 * scene.add( line );
	 * ```
	 *
	 * @augments Object3D
	 */ class Line extends Object3D {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
	        this.geometry = source.geometry;
	        return this;
	    }
	    /**
		 * Computes an array of distance values which are necessary for rendering dashed lines.
		 * For each vertex in the geometry, the method calculates the cumulative length from the
		 * current point to the very beginning of the line.
		 *
		 * @return {Line} A reference to this line.
		 */ computeLineDistances() {
	        const geometry = this.geometry;
	        // we assume non-indexed geometry
	        if (geometry.index === null) {
	            const positionAttribute = geometry.attributes.position;
	            const lineDistances = [
	                0
	            ];
	            for(let i = 1, l = positionAttribute.count; i < l; i++){
	                _vStart.fromBufferAttribute(positionAttribute, i - 1);
	                _vEnd.fromBufferAttribute(positionAttribute, i);
	                lineDistances[i] = lineDistances[i - 1];
	                lineDistances[i] += _vStart.distanceTo(_vEnd);
	            }
	            geometry.setAttribute('lineDistance', new Float32BufferAttribute(lineDistances, 1));
	        } else {
	            console.warn('THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.');
	        }
	        return this;
	    }
	    /**
		 * Computes intersection points between a casted ray and this line.
		 *
		 * @param {Raycaster} raycaster - The raycaster.
		 * @param {Array<Object>} intersects - The target array that holds the intersection points.
		 */ raycast(raycaster, intersects) {
	        const geometry = this.geometry;
	        const matrixWorld = this.matrixWorld;
	        const threshold = raycaster.params.Line.threshold;
	        const drawRange = geometry.drawRange;
	        // Checking boundingSphere distance to ray
	        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
	        _sphere$1.copy(geometry.boundingSphere);
	        _sphere$1.applyMatrix4(matrixWorld);
	        _sphere$1.radius += threshold;
	        if (raycaster.ray.intersectsSphere(_sphere$1) === false) return;
	        //
	        _inverseMatrix$1.copy(matrixWorld).invert();
	        _ray$1.copy(raycaster.ray).applyMatrix4(_inverseMatrix$1);
	        const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
	        const localThresholdSq = localThreshold * localThreshold;
	        const step = this.isLineSegments ? 2 : 1;
	        const index = geometry.index;
	        const attributes = geometry.attributes;
	        const positionAttribute = attributes.position;
	        if (index !== null) {
	            const start = Math.max(0, drawRange.start);
	            const end = Math.min(index.count, drawRange.start + drawRange.count);
	            for(let i = start, l = end - 1; i < l; i += step){
	                const a = index.getX(i);
	                const b = index.getX(i + 1);
	                const intersect = checkIntersection(this, raycaster, _ray$1, localThresholdSq, a, b, i);
	                if (intersect) {
	                    intersects.push(intersect);
	                }
	            }
	            if (this.isLineLoop) {
	                const a = index.getX(end - 1);
	                const b = index.getX(start);
	                const intersect = checkIntersection(this, raycaster, _ray$1, localThresholdSq, a, b, end - 1);
	                if (intersect) {
	                    intersects.push(intersect);
	                }
	            }
	        } else {
	            const start = Math.max(0, drawRange.start);
	            const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count);
	            for(let i = start, l = end - 1; i < l; i += step){
	                const intersect = checkIntersection(this, raycaster, _ray$1, localThresholdSq, i, i + 1, i);
	                if (intersect) {
	                    intersects.push(intersect);
	                }
	            }
	            if (this.isLineLoop) {
	                const intersect = checkIntersection(this, raycaster, _ray$1, localThresholdSq, end - 1, start, end - 1);
	                if (intersect) {
	                    intersects.push(intersect);
	                }
	            }
	        }
	    }
	    /**
		 * Sets the values of {@link Line#morphTargetDictionary} and {@link Line#morphTargetInfluences}
		 * to make sure existing morph targets can influence this 3D object.
		 */ updateMorphTargets() {
	        const geometry = this.geometry;
	        const morphAttributes = geometry.morphAttributes;
	        const keys = Object.keys(morphAttributes);
	        if (keys.length > 0) {
	            const morphAttribute = morphAttributes[keys[0]];
	            if (morphAttribute !== undefined) {
	                this.morphTargetInfluences = [];
	                this.morphTargetDictionary = {};
	                for(let m = 0, ml = morphAttribute.length; m < ml; m++){
	                    const name = morphAttribute[m].name || String(m);
	                    this.morphTargetInfluences.push(0);
	                    this.morphTargetDictionary[name] = m;
	                }
	            }
	        }
	    }
	    /**
		 * Constructs a new line.
		 *
		 * @param {BufferGeometry} [geometry] - The line geometry.
		 * @param {Material|Array<Material>} [material] - The line material.
		 */ constructor(geometry = new BufferGeometry(), material = new LineBasicMaterial()){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isLine = true;
	        this.type = 'Line';
	        /**
			 * The line geometry.
			 *
			 * @type {BufferGeometry}
			 */ this.geometry = geometry;
	        /**
			 * The line material.
			 *
			 * @type {Material|Array<Material>}
			 * @default LineBasicMaterial
			 */ this.material = material;
	        /**
			 * A dictionary representing the morph targets in the geometry. The key is the
			 * morph targets name, the value its attribute index. This member is `undefined`
			 * by default and only set when morph targets are detected in the geometry.
			 *
			 * @type {Object<String,number>|undefined}
			 * @default undefined
			 */ this.morphTargetDictionary = undefined;
	        /**
			 * An array of weights typically in the range `[0,1]` that specify how much of the morph
			 * is applied. This member is `undefined` by default and only set when morph targets are
			 * detected in the geometry.
			 *
			 * @type {Array<number>|undefined}
			 * @default undefined
			 */ this.morphTargetInfluences = undefined;
	        this.updateMorphTargets();
	    }
	}
	function checkIntersection(object, raycaster, ray, thresholdSq, a, b, i) {
	    const positionAttribute = object.geometry.attributes.position;
	    _vStart.fromBufferAttribute(positionAttribute, a);
	    _vEnd.fromBufferAttribute(positionAttribute, b);
	    const distSq = ray.distanceSqToSegment(_vStart, _vEnd, _intersectPointOnRay, _intersectPointOnSegment);
	    if (distSq > thresholdSq) return;
	    _intersectPointOnRay.applyMatrix4(object.matrixWorld); // Move back to world space for distance calculation
	    const distance = raycaster.ray.origin.distanceTo(_intersectPointOnRay);
	    if (distance < raycaster.near || distance > raycaster.far) return;
	    return {
	        distance: distance,
	        // What do we want? intersection point on the ray or on the segment??
	        // point: raycaster.ray.at( distance ),
	        point: _intersectPointOnSegment.clone().applyMatrix4(object.matrixWorld),
	        index: i,
	        face: null,
	        faceIndex: null,
	        barycoord: null,
	        object: object
	    };
	}
	const _start = /*@__PURE__*/ new Vector3();
	const _end = /*@__PURE__*/ new Vector3();
	/**
	 * A series of lines drawn between pairs of vertices.
	 *
	 * @augments Line
	 */ class LineSegments extends Line {
	    computeLineDistances() {
	        const geometry = this.geometry;
	        // we assume non-indexed geometry
	        if (geometry.index === null) {
	            const positionAttribute = geometry.attributes.position;
	            const lineDistances = [];
	            for(let i = 0, l = positionAttribute.count; i < l; i += 2){
	                _start.fromBufferAttribute(positionAttribute, i);
	                _end.fromBufferAttribute(positionAttribute, i + 1);
	                lineDistances[i] = i === 0 ? 0 : lineDistances[i - 1];
	                lineDistances[i + 1] = lineDistances[i] + _start.distanceTo(_end);
	            }
	            geometry.setAttribute('lineDistance', new Float32BufferAttribute(lineDistances, 1));
	        } else {
	            console.warn('THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.');
	        }
	        return this;
	    }
	    /**
		 * Constructs a new line segments.
		 *
		 * @param {BufferGeometry} [geometry] - The line geometry.
		 * @param {Material|Array<Material>} [material] - The line material.
		 */ constructor(geometry, material){
	        super(geometry, material);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isLineSegments = true;
	        this.type = 'LineSegments';
	    }
	}
	/**
	 * A continuous line. This is nearly the same as {@link Line} the only difference
	 * is that the last vertex is connected with the first vertex in order to close
	 * the line to form a loop.
	 *
	 * @augments Line
	 */ class LineLoop extends Line {
	    /**
		 * Constructs a new line loop.
		 *
		 * @param {BufferGeometry} [geometry] - The line geometry.
		 * @param {Material|Array<Material>} [material] - The line material.
		 */ constructor(geometry, material){
	        super(geometry, material);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isLineLoop = true;
	        this.type = 'LineLoop';
	    }
	}
	class PointsMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.color.copy(source.color);
	        this.map = source.map;
	        this.alphaMap = source.alphaMap;
	        this.size = source.size;
	        this.sizeAttenuation = source.sizeAttenuation;
	        this.fog = source.fog;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isPointsMaterial = true;
	        this.type = 'PointsMaterial';
	        this.color = new Color(0xffffff);
	        this.map = null;
	        this.alphaMap = null;
	        this.size = 1;
	        this.sizeAttenuation = true;
	        this.fog = true;
	        this.setValues(parameters);
	    }
	}
	const _inverseMatrix = /*@__PURE__*/ new Matrix4();
	const _ray = /*@__PURE__*/ new Ray();
	const _sphere = /*@__PURE__*/ new Sphere();
	const _position$2 = /*@__PURE__*/ new Vector3();
	/**
	 * A class for displaying points or point clouds.
	 *
	 * @augments Object3D
	 */ class Points extends Object3D {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
	        this.geometry = source.geometry;
	        return this;
	    }
	    /**
		 * Computes intersection points between a casted ray and this point cloud.
		 *
		 * @param {Raycaster} raycaster - The raycaster.
		 * @param {Array<Object>} intersects - The target array that holds the intersection points.
		 */ raycast(raycaster, intersects) {
	        const geometry = this.geometry;
	        const matrixWorld = this.matrixWorld;
	        const threshold = raycaster.params.Points.threshold;
	        const drawRange = geometry.drawRange;
	        // Checking boundingSphere distance to ray
	        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
	        _sphere.copy(geometry.boundingSphere);
	        _sphere.applyMatrix4(matrixWorld);
	        _sphere.radius += threshold;
	        if (raycaster.ray.intersectsSphere(_sphere) === false) return;
	        //
	        _inverseMatrix.copy(matrixWorld).invert();
	        _ray.copy(raycaster.ray).applyMatrix4(_inverseMatrix);
	        const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
	        const localThresholdSq = localThreshold * localThreshold;
	        const index = geometry.index;
	        const attributes = geometry.attributes;
	        const positionAttribute = attributes.position;
	        if (index !== null) {
	            const start = Math.max(0, drawRange.start);
	            const end = Math.min(index.count, drawRange.start + drawRange.count);
	            for(let i = start, il = end; i < il; i++){
	                const a = index.getX(i);
	                _position$2.fromBufferAttribute(positionAttribute, a);
	                testPoint(_position$2, a, localThresholdSq, matrixWorld, raycaster, intersects, this);
	            }
	        } else {
	            const start = Math.max(0, drawRange.start);
	            const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count);
	            for(let i = start, l = end; i < l; i++){
	                _position$2.fromBufferAttribute(positionAttribute, i);
	                testPoint(_position$2, i, localThresholdSq, matrixWorld, raycaster, intersects, this);
	            }
	        }
	    }
	    /**
		 * Sets the values of {@link Points#morphTargetDictionary} and {@link Points#morphTargetInfluences}
		 * to make sure existing morph targets can influence this 3D object.
		 */ updateMorphTargets() {
	        const geometry = this.geometry;
	        const morphAttributes = geometry.morphAttributes;
	        const keys = Object.keys(morphAttributes);
	        if (keys.length > 0) {
	            const morphAttribute = morphAttributes[keys[0]];
	            if (morphAttribute !== undefined) {
	                this.morphTargetInfluences = [];
	                this.morphTargetDictionary = {};
	                for(let m = 0, ml = morphAttribute.length; m < ml; m++){
	                    const name = morphAttribute[m].name || String(m);
	                    this.morphTargetInfluences.push(0);
	                    this.morphTargetDictionary[name] = m;
	                }
	            }
	        }
	    }
	    /**
		 * Constructs a new point cloud.
		 *
		 * @param {BufferGeometry} [geometry] - The points geometry.
		 * @param {Material|Array<Material>} [material] - The points material.
		 */ constructor(geometry = new BufferGeometry(), material = new PointsMaterial()){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isPoints = true;
	        this.type = 'Points';
	        /**
			 * The points geometry.
			 *
			 * @type {BufferGeometry}
			 */ this.geometry = geometry;
	        /**
			 * The line material.
			 *
			 * @type {Material|Array<Material>}
			 * @default PointsMaterial
			 */ this.material = material;
	        /**
			 * A dictionary representing the morph targets in the geometry. The key is the
			 * morph targets name, the value its attribute index. This member is `undefined`
			 * by default and only set when morph targets are detected in the geometry.
			 *
			 * @type {Object<String,number>|undefined}
			 * @default undefined
			 */ this.morphTargetDictionary = undefined;
	        /**
			 * An array of weights typically in the range `[0,1]` that specify how much of the morph
			 * is applied. This member is `undefined` by default and only set when morph targets are
			 * detected in the geometry.
			 *
			 * @type {Array<number>|undefined}
			 * @default undefined
			 */ this.morphTargetInfluences = undefined;
	        this.updateMorphTargets();
	    }
	}
	function testPoint(point, index, localThresholdSq, matrixWorld, raycaster, intersects, object) {
	    const rayPointDistanceSq = _ray.distanceSqToPoint(point);
	    if (rayPointDistanceSq < localThresholdSq) {
	        const intersectPoint = new Vector3();
	        _ray.closestPointToPoint(point, intersectPoint);
	        intersectPoint.applyMatrix4(matrixWorld);
	        const distance = raycaster.ray.origin.distanceTo(intersectPoint);
	        if (distance < raycaster.near || distance > raycaster.far) return;
	        intersects.push({
	            distance: distance,
	            distanceToRay: Math.sqrt(rayPointDistanceSq),
	            point: intersectPoint,
	            index: index,
	            face: null,
	            faceIndex: null,
	            barycoord: null,
	            object: object
	        });
	    }
	}
	class VideoTexture extends Texture$1 {
	    clone() {
	        return new this.constructor(this.image).copy(this);
	    }
	    update() {
	        const video = this.image;
	        const hasVideoFrameCallback = 'requestVideoFrameCallback' in video;
	        if (hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA) {
	            this.needsUpdate = true;
	        }
	    }
	    constructor(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy){
	        super(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
	        this.isVideoTexture = true;
	        this.minFilter = minFilter !== undefined ? minFilter : LinearFilter;
	        this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;
	        this.generateMipmaps = false;
	        const scope = this;
	        function updateVideo() {
	            scope.needsUpdate = true;
	            video.requestVideoFrameCallback(updateVideo);
	        }
	        if ('requestVideoFrameCallback' in video) {
	            video.requestVideoFrameCallback(updateVideo);
	        }
	    }
	}
	class CompressedTexture extends Texture$1 {
	    constructor(mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace){
	        super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
	        this.isCompressedTexture = true;
	        this.image = {
	            width: width,
	            height: height
	        };
	        this.mipmaps = mipmaps;
	        // no flipping for cube textures
	        // (also flipping doesn't work for compressed textures )
	        this.flipY = false;
	        // can't generate mipmaps for compressed textures
	        // mips must be embedded in DDS files
	        this.generateMipmaps = false;
	    }
	}
	class CompressedArrayTexture extends CompressedTexture {
	    addLayerUpdate(layerIndex) {
	        this.layerUpdates.add(layerIndex);
	    }
	    clearLayerUpdates() {
	        this.layerUpdates.clear();
	    }
	    constructor(mipmaps, width, height, depth, format, type){
	        super(mipmaps, width, height, format, type);
	        this.isCompressedArrayTexture = true;
	        this.image.depth = depth;
	        this.wrapR = ClampToEdgeWrapping;
	        this.layerUpdates = new Set();
	    }
	}
	class CompressedCubeTexture extends CompressedTexture {
	    constructor(images, format, type){
	        super(undefined, images[0].width, images[0].height, format, type, CubeReflectionMapping);
	        this.isCompressedCubeTexture = true;
	        this.isCubeTexture = true;
	        this.image = images;
	    }
	}
	class CanvasTexture extends Texture$1 {
	    constructor(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy){
	        super(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
	        this.isCanvasTexture = true;
	        this.needsUpdate = true;
	    }
	}
	class DepthTexture extends Texture$1 {
	    copy(source) {
	        super.copy(source);
	        this.source = new Source(Object.assign({}, source.image)); // see #30540
	        this.compareFunction = source.compareFunction;
	        return this;
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        if (this.compareFunction !== null) data.compareFunction = this.compareFunction;
	        return data;
	    }
	    constructor(width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format = DepthFormat){
	        if (format !== DepthFormat && format !== DepthStencilFormat) {
	            throw new Error('DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat');
	        }
	        if (type === undefined && format === DepthFormat) type = UnsignedIntType;
	        if (type === undefined && format === DepthStencilFormat) type = UnsignedInt248Type;
	        super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
	        this.isDepthTexture = true;
	        this.image = {
	            width: width,
	            height: height
	        };
	        this.magFilter = magFilter !== undefined ? magFilter : NearestFilter;
	        this.minFilter = minFilter !== undefined ? minFilter : NearestFilter;
	        this.flipY = false;
	        this.generateMipmaps = false;
	        this.compareFunction = null;
	    }
	}
	/**
	 * A geometry class for representing a plane.
	 *
	 * ```js
	 * const geometry = new THREE.PlaneGeometry( 1, 1 );
	 * const material = new THREE.MeshBasicMaterial( { color: 0xffff00, side: THREE.DoubleSide } );
	 * const plane = new THREE.Mesh( geometry, material );
	 * scene.add( plane );
	 * ```
	 *
	 * @augments BufferGeometry
	 */ class PlaneGeometry extends BufferGeometry {
	    copy(source) {
	        super.copy(source);
	        this.parameters = Object.assign({}, source.parameters);
	        return this;
	    }
	    /**
		 * Factory method for creating an instance of this class from the given
		 * JSON object.
		 *
		 * @param {Object} data - A JSON object representing the serialized geometry.
		 * @return {PlaneGeometry} A new instance.
		 */ static fromJSON(data) {
	        return new PlaneGeometry(data.width, data.height, data.widthSegments, data.heightSegments);
	    }
	    /**
		 * Constructs a new plane geometry.
		 *
		 * @param {number} [width=1] - The width along the X axis.
		 * @param {number} [height=1] - The height along the Y axis
		 * @param {number} [widthSegments=1] - The number of segments along the X axis.
		 * @param {number} [heightSegments=1] - The number of segments along the Y axis.
		 */ constructor(width = 1, height = 1, widthSegments = 1, heightSegments = 1){
	        super();
	        this.type = 'PlaneGeometry';
	        /**
			 * Holds the constructor parameters that have been
			 * used to generate the geometry. Any modification
			 * after instantiation does not change the geometry.
			 *
			 * @type {Object}
			 */ this.parameters = {
	            width: width,
	            height: height,
	            widthSegments: widthSegments,
	            heightSegments: heightSegments
	        };
	        const width_half = width / 2;
	        const height_half = height / 2;
	        const gridX = Math.floor(widthSegments);
	        const gridY = Math.floor(heightSegments);
	        const gridX1 = gridX + 1;
	        const gridY1 = gridY + 1;
	        const segment_width = width / gridX;
	        const segment_height = height / gridY;
	        //
	        const indices = [];
	        const vertices = [];
	        const normals = [];
	        const uvs = [];
	        for(let iy = 0; iy < gridY1; iy++){
	            const y = iy * segment_height - height_half;
	            for(let ix = 0; ix < gridX1; ix++){
	                const x = ix * segment_width - width_half;
	                vertices.push(x, -y, 0);
	                normals.push(0, 0, 1);
	                uvs.push(ix / gridX);
	                uvs.push(1 - iy / gridY);
	            }
	        }
	        for(let iy = 0; iy < gridY; iy++){
	            for(let ix = 0; ix < gridX; ix++){
	                const a = ix + gridX1 * iy;
	                const b = ix + gridX1 * (iy + 1);
	                const c = ix + 1 + gridX1 * (iy + 1);
	                const d = ix + 1 + gridX1 * iy;
	                indices.push(a, b, d);
	                indices.push(b, c, d);
	            }
	        }
	        this.setIndex(indices);
	        this.setAttribute('position', new Float32BufferAttribute(vertices, 3));
	        this.setAttribute('normal', new Float32BufferAttribute(normals, 3));
	        this.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
	    }
	}
	/**
	 * A class for generating a sphere geometry.
	 *
	 * ```js
	 * const geometry = new THREE.SphereGeometry( 15, 32, 16 );
	 * const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
	 * const sphere = new THREE.Mesh( geometry, material );
	 * scene.add( sphere );
	 * ```
	 *
	 * @augments BufferGeometry
	 */ class SphereGeometry extends BufferGeometry {
	    copy(source) {
	        super.copy(source);
	        this.parameters = Object.assign({}, source.parameters);
	        return this;
	    }
	    /**
		 * Factory method for creating an instance of this class from the given
		 * JSON object.
		 *
		 * @param {Object} data - A JSON object representing the serialized geometry.
		 * @return {SphereGeometry} A new instance.
		 */ static fromJSON(data) {
	        return new SphereGeometry(data.radius, data.widthSegments, data.heightSegments, data.phiStart, data.phiLength, data.thetaStart, data.thetaLength);
	    }
	    /**
		 * Constructs a new sphere geometry.
		 *
		 * @param {number} [radius=1] - The sphere radius.
		 * @param {number} [widthSegments=32] - The number of horizontal segments. Minimum value is `3`.
		 * @param {number} [heightSegments=16] - The number of vertical segments. Minimum value is `2`.
		 * @param {number} [phiStart=0] - The horizontal starting angle in radians.
		 * @param {number} [phiLength=Math.PI*2] - The horizontal sweep angle size.
		 * @param {number} [thetaStart=0] - The vertical starting angle in radians.
		 * @param {number} [thetaLength=Math.PI] - The vertical sweep angle size.
		 */ constructor(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI){
	        super();
	        this.type = 'SphereGeometry';
	        /**
			 * Holds the constructor parameters that have been
			 * used to generate the geometry. Any modification
			 * after instantiation does not change the geometry.
			 *
			 * @type {Object}
			 */ this.parameters = {
	            radius: radius,
	            widthSegments: widthSegments,
	            heightSegments: heightSegments,
	            phiStart: phiStart,
	            phiLength: phiLength,
	            thetaStart: thetaStart,
	            thetaLength: thetaLength
	        };
	        widthSegments = Math.max(3, Math.floor(widthSegments));
	        heightSegments = Math.max(2, Math.floor(heightSegments));
	        const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI);
	        let index = 0;
	        const grid = [];
	        const vertex = new Vector3();
	        const normal = new Vector3();
	        // buffers
	        const indices = [];
	        const vertices = [];
	        const normals = [];
	        const uvs = [];
	        // generate vertices, normals and uvs
	        for(let iy = 0; iy <= heightSegments; iy++){
	            const verticesRow = [];
	            const v = iy / heightSegments;
	            // special case for the poles
	            let uOffset = 0;
	            if (iy === 0 && thetaStart === 0) {
	                uOffset = 0.5 / widthSegments;
	            } else if (iy === heightSegments && thetaEnd === Math.PI) {
	                uOffset = -0.5 / widthSegments;
	            }
	            for(let ix = 0; ix <= widthSegments; ix++){
	                const u = ix / widthSegments;
	                // vertex
	                vertex.x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
	                vertex.y = radius * Math.cos(thetaStart + v * thetaLength);
	                vertex.z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
	                vertices.push(vertex.x, vertex.y, vertex.z);
	                // normal
	                normal.copy(vertex).normalize();
	                normals.push(normal.x, normal.y, normal.z);
	                // uv
	                uvs.push(u + uOffset, 1 - v);
	                verticesRow.push(index++);
	            }
	            grid.push(verticesRow);
	        }
	        // indices
	        for(let iy = 0; iy < heightSegments; iy++){
	            for(let ix = 0; ix < widthSegments; ix++){
	                const a = grid[iy][ix + 1];
	                const b = grid[iy][ix];
	                const c = grid[iy + 1][ix];
	                const d = grid[iy + 1][ix + 1];
	                if (iy !== 0 || thetaStart > 0) indices.push(a, b, d);
	                if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d);
	            }
	        }
	        // build geometry
	        this.setIndex(indices);
	        this.setAttribute('position', new Float32BufferAttribute(vertices, 3));
	        this.setAttribute('normal', new Float32BufferAttribute(normals, 3));
	        this.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
	    }
	}
	class MeshStandardMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.defines = {
	            'STANDARD': ''
	        };
	        this.color.copy(source.color);
	        this.roughness = source.roughness;
	        this.metalness = source.metalness;
	        this.map = source.map;
	        this.lightMap = source.lightMap;
	        this.lightMapIntensity = source.lightMapIntensity;
	        this.aoMap = source.aoMap;
	        this.aoMapIntensity = source.aoMapIntensity;
	        this.emissive.copy(source.emissive);
	        this.emissiveMap = source.emissiveMap;
	        this.emissiveIntensity = source.emissiveIntensity;
	        this.bumpMap = source.bumpMap;
	        this.bumpScale = source.bumpScale;
	        this.normalMap = source.normalMap;
	        this.normalMapType = source.normalMapType;
	        this.normalScale.copy(source.normalScale);
	        this.displacementMap = source.displacementMap;
	        this.displacementScale = source.displacementScale;
	        this.displacementBias = source.displacementBias;
	        this.roughnessMap = source.roughnessMap;
	        this.metalnessMap = source.metalnessMap;
	        this.alphaMap = source.alphaMap;
	        this.envMap = source.envMap;
	        this.envMapRotation.copy(source.envMapRotation);
	        this.envMapIntensity = source.envMapIntensity;
	        this.wireframe = source.wireframe;
	        this.wireframeLinewidth = source.wireframeLinewidth;
	        this.wireframeLinecap = source.wireframeLinecap;
	        this.wireframeLinejoin = source.wireframeLinejoin;
	        this.flatShading = source.flatShading;
	        this.fog = source.fog;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isMeshStandardMaterial = true;
	        this.type = 'MeshStandardMaterial';
	        this.defines = {
	            'STANDARD': ''
	        };
	        this.color = new Color(0xffffff); // diffuse
	        this.roughness = 1.0;
	        this.metalness = 0.0;
	        this.map = null;
	        this.lightMap = null;
	        this.lightMapIntensity = 1.0;
	        this.aoMap = null;
	        this.aoMapIntensity = 1.0;
	        this.emissive = new Color(0x000000);
	        this.emissiveIntensity = 1.0;
	        this.emissiveMap = null;
	        this.bumpMap = null;
	        this.bumpScale = 1;
	        this.normalMap = null;
	        this.normalMapType = TangentSpaceNormalMap;
	        this.normalScale = new Vector2(1, 1);
	        this.displacementMap = null;
	        this.displacementScale = 1;
	        this.displacementBias = 0;
	        this.roughnessMap = null;
	        this.metalnessMap = null;
	        this.alphaMap = null;
	        this.envMap = null;
	        this.envMapRotation = new Euler();
	        this.envMapIntensity = 1.0;
	        this.wireframe = false;
	        this.wireframeLinewidth = 1;
	        this.wireframeLinecap = 'round';
	        this.wireframeLinejoin = 'round';
	        this.flatShading = false;
	        this.fog = true;
	        this.setValues(parameters);
	    }
	}
	class MeshPhysicalMaterial extends MeshStandardMaterial {
	    get anisotropy() {
	        return this._anisotropy;
	    }
	    set anisotropy(value) {
	        if (this._anisotropy > 0 !== value > 0) {
	            this.version++;
	        }
	        this._anisotropy = value;
	    }
	    get clearcoat() {
	        return this._clearcoat;
	    }
	    set clearcoat(value) {
	        if (this._clearcoat > 0 !== value > 0) {
	            this.version++;
	        }
	        this._clearcoat = value;
	    }
	    get iridescence() {
	        return this._iridescence;
	    }
	    set iridescence(value) {
	        if (this._iridescence > 0 !== value > 0) {
	            this.version++;
	        }
	        this._iridescence = value;
	    }
	    get dispersion() {
	        return this._dispersion;
	    }
	    set dispersion(value) {
	        if (this._dispersion > 0 !== value > 0) {
	            this.version++;
	        }
	        this._dispersion = value;
	    }
	    get sheen() {
	        return this._sheen;
	    }
	    set sheen(value) {
	        if (this._sheen > 0 !== value > 0) {
	            this.version++;
	        }
	        this._sheen = value;
	    }
	    get transmission() {
	        return this._transmission;
	    }
	    set transmission(value) {
	        if (this._transmission > 0 !== value > 0) {
	            this.version++;
	        }
	        this._transmission = value;
	    }
	    copy(source) {
	        super.copy(source);
	        this.defines = {
	            'STANDARD': '',
	            'PHYSICAL': ''
	        };
	        this.anisotropy = source.anisotropy;
	        this.anisotropyRotation = source.anisotropyRotation;
	        this.anisotropyMap = source.anisotropyMap;
	        this.clearcoat = source.clearcoat;
	        this.clearcoatMap = source.clearcoatMap;
	        this.clearcoatRoughness = source.clearcoatRoughness;
	        this.clearcoatRoughnessMap = source.clearcoatRoughnessMap;
	        this.clearcoatNormalMap = source.clearcoatNormalMap;
	        this.clearcoatNormalScale.copy(source.clearcoatNormalScale);
	        this.dispersion = source.dispersion;
	        this.ior = source.ior;
	        this.iridescence = source.iridescence;
	        this.iridescenceMap = source.iridescenceMap;
	        this.iridescenceIOR = source.iridescenceIOR;
	        this.iridescenceThicknessRange = [
	            ...source.iridescenceThicknessRange
	        ];
	        this.iridescenceThicknessMap = source.iridescenceThicknessMap;
	        this.sheen = source.sheen;
	        this.sheenColor.copy(source.sheenColor);
	        this.sheenColorMap = source.sheenColorMap;
	        this.sheenRoughness = source.sheenRoughness;
	        this.sheenRoughnessMap = source.sheenRoughnessMap;
	        this.transmission = source.transmission;
	        this.transmissionMap = source.transmissionMap;
	        this.thickness = source.thickness;
	        this.thicknessMap = source.thicknessMap;
	        this.attenuationDistance = source.attenuationDistance;
	        this.attenuationColor.copy(source.attenuationColor);
	        this.specularIntensity = source.specularIntensity;
	        this.specularIntensityMap = source.specularIntensityMap;
	        this.specularColor.copy(source.specularColor);
	        this.specularColorMap = source.specularColorMap;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isMeshPhysicalMaterial = true;
	        this.defines = {
	            'STANDARD': '',
	            'PHYSICAL': ''
	        };
	        this.type = 'MeshPhysicalMaterial';
	        this.anisotropyRotation = 0;
	        this.anisotropyMap = null;
	        this.clearcoatMap = null;
	        this.clearcoatRoughness = 0.0;
	        this.clearcoatRoughnessMap = null;
	        this.clearcoatNormalScale = new Vector2(1, 1);
	        this.clearcoatNormalMap = null;
	        this.ior = 1.5;
	        Object.defineProperty(this, 'reflectivity', {
	            get: function() {
	                return clamp$1(2.5 * (this.ior - 1) / (this.ior + 1), 0, 1);
	            },
	            set: function(reflectivity) {
	                this.ior = (1 + 0.4 * reflectivity) / (1 - 0.4 * reflectivity);
	            }
	        });
	        this.iridescenceMap = null;
	        this.iridescenceIOR = 1.3;
	        this.iridescenceThicknessRange = [
	            100,
	            400
	        ];
	        this.iridescenceThicknessMap = null;
	        this.sheenColor = new Color(0x000000);
	        this.sheenColorMap = null;
	        this.sheenRoughness = 1.0;
	        this.sheenRoughnessMap = null;
	        this.transmissionMap = null;
	        this.thickness = 0;
	        this.thicknessMap = null;
	        this.attenuationDistance = Infinity;
	        this.attenuationColor = new Color(1, 1, 1);
	        this.specularIntensity = 1.0;
	        this.specularIntensityMap = null;
	        this.specularColor = new Color(1, 1, 1);
	        this.specularColorMap = null;
	        this._anisotropy = 0;
	        this._clearcoat = 0;
	        this._dispersion = 0;
	        this._iridescence = 0;
	        this._sheen = 0.0;
	        this._transmission = 0;
	        this.setValues(parameters);
	    }
	}
	class MeshDepthMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.depthPacking = source.depthPacking;
	        this.map = source.map;
	        this.alphaMap = source.alphaMap;
	        this.displacementMap = source.displacementMap;
	        this.displacementScale = source.displacementScale;
	        this.displacementBias = source.displacementBias;
	        this.wireframe = source.wireframe;
	        this.wireframeLinewidth = source.wireframeLinewidth;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isMeshDepthMaterial = true;
	        this.type = 'MeshDepthMaterial';
	        this.depthPacking = BasicDepthPacking;
	        this.map = null;
	        this.alphaMap = null;
	        this.displacementMap = null;
	        this.displacementScale = 1;
	        this.displacementBias = 0;
	        this.wireframe = false;
	        this.wireframeLinewidth = 1;
	        this.setValues(parameters);
	    }
	}
	class MeshDistanceMaterial extends Material$1 {
	    copy(source) {
	        super.copy(source);
	        this.map = source.map;
	        this.alphaMap = source.alphaMap;
	        this.displacementMap = source.displacementMap;
	        this.displacementScale = source.displacementScale;
	        this.displacementBias = source.displacementBias;
	        return this;
	    }
	    constructor(parameters){
	        super();
	        this.isMeshDistanceMaterial = true;
	        this.type = 'MeshDistanceMaterial';
	        this.map = null;
	        this.alphaMap = null;
	        this.displacementMap = null;
	        this.displacementScale = 1;
	        this.displacementBias = 0;
	        this.setValues(parameters);
	    }
	}
	// converts an array to a specific type
	function convertArray(array, type, forceClone) {
	    if (!array || // let 'undefined' and 'null' pass
	    !forceClone && array.constructor === type) return array;
	    if (typeof type.BYTES_PER_ELEMENT === 'number') {
	        return new type(array); // create typed array
	    }
	    return Array.prototype.slice.call(array); // create Array
	}
	function isTypedArray(object) {
	    return ArrayBuffer.isView(object) && !(object instanceof DataView);
	}
	// returns an array by which times and values can be sorted
	function getKeyframeOrder(times) {
	    function compareTime(i, j) {
	        return times[i] - times[j];
	    }
	    const n = times.length;
	    const result = new Array(n);
	    for(let i = 0; i !== n; ++i)result[i] = i;
	    result.sort(compareTime);
	    return result;
	}
	// uses the array previously returned by 'getKeyframeOrder' to sort data
	function sortedArray(values, stride, order) {
	    const nValues = values.length;
	    const result = new values.constructor(nValues);
	    for(let i = 0, dstOffset = 0; dstOffset !== nValues; ++i){
	        const srcOffset = order[i] * stride;
	        for(let j = 0; j !== stride; ++j){
	            result[dstOffset++] = values[srcOffset + j];
	        }
	    }
	    return result;
	}
	// function for parsing AOS keyframe formats
	function flattenJSON(jsonKeys, times, values, valuePropertyName) {
	    let i = 1, key = jsonKeys[0];
	    while(key !== undefined && key[valuePropertyName] === undefined){
	        key = jsonKeys[i++];
	    }
	    if (key === undefined) return; // no data
	    let value = key[valuePropertyName];
	    if (value === undefined) return; // no data
	    if (Array.isArray(value)) {
	        do {
	            value = key[valuePropertyName];
	            if (value !== undefined) {
	                times.push(key.time);
	                values.push(...value); // push all elements
	            }
	            key = jsonKeys[i++];
	        }while (key !== undefined)
	    } else if (value.toArray !== undefined) {
	        // ...assume THREE.Math-ish
	        do {
	            value = key[valuePropertyName];
	            if (value !== undefined) {
	                times.push(key.time);
	                value.toArray(values, values.length);
	            }
	            key = jsonKeys[i++];
	        }while (key !== undefined)
	    } else {
	        // otherwise push as-is
	        do {
	            value = key[valuePropertyName];
	            if (value !== undefined) {
	                times.push(key.time);
	                values.push(value);
	            }
	            key = jsonKeys[i++];
	        }while (key !== undefined)
	    }
	}
	/**
	 * Abstract base class of interpolants over parametric samples.
	 *
	 * The parameter domain is one dimensional, typically the time or a path
	 * along a curve defined by the data.
	 *
	 * The sample values can have any dimensionality and derived classes may
	 * apply special interpretations to the data.
	 *
	 * This class provides the interval seek in a Template Method, deferring
	 * the actual interpolation to derived classes.
	 *
	 * Time complexity is O(1) for linear access crossing at most two points
	 * and O(log N) for random access, where N is the number of positions.
	 *
	 * References: {@link http://www.oodesign.com/template-method-pattern.html}
	 *
	 * @abstract
	 */ class Interpolant {
	    /**
		 * Evaluate the interpolant at position `t`.
		 *
		 * @param {number} t - The interpolation factor.
		 * @return {TypedArray} The result buffer.
		 */ evaluate(t) {
	        const pp = this.parameterPositions;
	        let i1 = this._cachedIndex, t1 = pp[i1], t0 = pp[i1 - 1];
	        validate_interval: {
	            seek: {
	                let right;
	                linear_scan: {
	                    //- See http://jsperf.com/comparison-to-undefined/3
	                    //- slower code:
	                    //-
	                    //- 				if ( t >= t1 || t1 === undefined ) {
	                    forward_scan: if (!(t < t1)) {
	                        for(let giveUpAt = i1 + 2;;){
	                            if (t1 === undefined) {
	                                if (t < t0) break forward_scan;
	                                // after end
	                                i1 = pp.length;
	                                this._cachedIndex = i1;
	                                return this.copySampleValue_(i1 - 1);
	                            }
	                            if (i1 === giveUpAt) break; // this loop
	                            t0 = t1;
	                            t1 = pp[++i1];
	                            if (t < t1) {
	                                break seek;
	                            }
	                        }
	                        // prepare binary search on the right side of the index
	                        right = pp.length;
	                        break linear_scan;
	                    }
	                    //- slower code:
	                    //-					if ( t < t0 || t0 === undefined ) {
	                    if (!(t >= t0)) {
	                        // looping?
	                        const t1global = pp[1];
	                        if (t < t1global) {
	                            i1 = 2; // + 1, using the scan for the details
	                            t0 = t1global;
	                        }
	                        // linear reverse scan
	                        for(let giveUpAt = i1 - 2;;){
	                            if (t0 === undefined) {
	                                // before start
	                                this._cachedIndex = 0;
	                                return this.copySampleValue_(0);
	                            }
	                            if (i1 === giveUpAt) break; // this loop
	                            t1 = t0;
	                            t0 = pp[--i1 - 1];
	                            if (t >= t0) {
	                                break seek;
	                            }
	                        }
	                        // prepare binary search on the left side of the index
	                        right = i1;
	                        i1 = 0;
	                        break linear_scan;
	                    }
	                    break validate_interval;
	                } // linear scan
	                // binary search
	                while(i1 < right){
	                    const mid = i1 + right >>> 1;
	                    if (t < pp[mid]) {
	                        right = mid;
	                    } else {
	                        i1 = mid + 1;
	                    }
	                }
	                t1 = pp[i1];
	                t0 = pp[i1 - 1];
	                // check boundary cases, again
	                if (t0 === undefined) {
	                    this._cachedIndex = 0;
	                    return this.copySampleValue_(0);
	                }
	                if (t1 === undefined) {
	                    i1 = pp.length;
	                    this._cachedIndex = i1;
	                    return this.copySampleValue_(i1 - 1);
	                }
	            } // seek
	            this._cachedIndex = i1;
	            this.intervalChanged_(i1, t0, t1);
	        } // validate_interval
	        return this.interpolate_(i1, t0, t, t1);
	    }
	    /**
		 * Returns the interpolation settings.
		 *
		 * @return {Object} The interpolation settings.
		 */ getSettings_() {
	        return this.settings || this.DefaultSettings_;
	    }
	    /**
		 * Copies a sample value to the result buffer.
		 *
		 * @param {number} index - An index into the sample value buffer.
		 * @return {TypedArray} The result buffer.
		 */ copySampleValue_(index) {
	        // copies a sample value to the result buffer
	        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset = index * stride;
	        for(let i = 0; i !== stride; ++i){
	            result[i] = values[offset + i];
	        }
	        return result;
	    }
	    /**
		 * Copies a sample value to the result buffer.
		 *
		 * @abstract
		 * @param {number} i1 - An index into the sample value buffer.
		 * @param {number} t0 - The previous interpolation factor.
		 * @param {number} t - The current interpolation factor.
		 * @param {number} t1 - The next interpolation factor.
		 * @return {TypedArray} The result buffer.
		 */ interpolate_() {
	        throw new Error('call to abstract method');
	    // implementations shall return this.resultBuffer
	    }
	    /**
		 * Optional method that is executed when the interval has changed.
		 *
		 * @param {number} i1 - An index into the sample value buffer.
		 * @param {number} t0 - The previous interpolation factor.
		 * @param {number} t - The current interpolation factor.
		 */ intervalChanged_() {
	    // empty
	    }
	    /**
		 * Constructs a new interpolant.
		 *
		 * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
		 * @param {TypedArray} sampleValues - The sample values.
		 * @param {number} sampleSize - The sample size
		 * @param {TypedArray} [resultBuffer] - The result buffer.
		 */ constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
	        /**
			 * The parameter positions.
			 *
			 * @type {TypedArray}
			 */ this.parameterPositions = parameterPositions;
	        /**
			 * A cache index.
			 *
			 * @private
			 * @type {number}
			 * @default 0
			 */ this._cachedIndex = 0;
	        /**
			 * The result buffer.
			 *
			 * @type {TypedArray}
			 */ this.resultBuffer = resultBuffer !== undefined ? resultBuffer : new sampleValues.constructor(sampleSize);
	        /**
			 * The sample values.
			 *
			 * @type {TypedArray}
			 */ this.sampleValues = sampleValues;
	        /**
			 * The value size.
			 *
			 * @type {TypedArray}
			 */ this.valueSize = sampleSize;
	        /**
			 * The interpolation settings.
			 *
			 * @type {?Object}
			 * @default null
			 */ this.settings = null;
	        /**
			 * The default settings object.
			 *
			 * @type {Object}
			 */ this.DefaultSettings_ = {};
	    }
	}
	/**
	 * Fast and simple cubic spline interpolant.
	 *
	 * It was derived from a Hermitian construction setting the first derivative
	 * at each sample position to the linear slope between neighboring positions
	 * over their parameter interval.
	 *
	 * @augments Interpolant
	 */ class CubicInterpolant extends Interpolant {
	    intervalChanged_(i1, t0, t1) {
	        const pp = this.parameterPositions;
	        let iPrev = i1 - 2, iNext = i1 + 1, tPrev = pp[iPrev], tNext = pp[iNext];
	        if (tPrev === undefined) {
	            switch(this.getSettings_().endingStart){
	                case ZeroSlopeEnding:
	                    // f'(t0) = 0
	                    iPrev = i1;
	                    tPrev = 2 * t0 - t1;
	                    break;
	                case WrapAroundEnding:
	                    // use the other end of the curve
	                    iPrev = pp.length - 2;
	                    tPrev = t0 + pp[iPrev] - pp[iPrev + 1];
	                    break;
	                default:
	                    // f''(t0) = 0 a.k.a. Natural Spline
	                    iPrev = i1;
	                    tPrev = t1;
	            }
	        }
	        if (tNext === undefined) {
	            switch(this.getSettings_().endingEnd){
	                case ZeroSlopeEnding:
	                    // f'(tN) = 0
	                    iNext = i1;
	                    tNext = 2 * t1 - t0;
	                    break;
	                case WrapAroundEnding:
	                    // use the other end of the curve
	                    iNext = 1;
	                    tNext = t1 + pp[1] - pp[0];
	                    break;
	                default:
	                    // f''(tN) = 0, a.k.a. Natural Spline
	                    iNext = i1 - 1;
	                    tNext = t0;
	            }
	        }
	        const halfDt = (t1 - t0) * 0.5, stride = this.valueSize;
	        this._weightPrev = halfDt / (t0 - tPrev);
	        this._weightNext = halfDt / (tNext - t1);
	        this._offsetPrev = iPrev * stride;
	        this._offsetNext = iNext * stride;
	    }
	    interpolate_(i1, t0, t, t1) {
	        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, o1 = i1 * stride, o0 = o1 - stride, oP = this._offsetPrev, oN = this._offsetNext, wP = this._weightPrev, wN = this._weightNext, p = (t - t0) / (t1 - t0), pp = p * p, ppp = pp * p;
	        // evaluate polynomials
	        const sP = -wP * ppp + 2 * wP * pp - wP * p;
	        const s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p + 1;
	        const s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p;
	        const sN = wN * ppp - wN * pp;
	        // combine data linearly
	        for(let i = 0; i !== stride; ++i){
	            result[i] = sP * values[oP + i] + s0 * values[o0 + i] + s1 * values[o1 + i] + sN * values[oN + i];
	        }
	        return result;
	    }
	    /**
		 * Constructs a new cubic interpolant.
		 *
		 * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
		 * @param {TypedArray} sampleValues - The sample values.
		 * @param {number} sampleSize - The sample size
		 * @param {TypedArray} [resultBuffer] - The result buffer.
		 */ constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
	        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
	        this._weightPrev = -0;
	        this._offsetPrev = -0;
	        this._weightNext = -0;
	        this._offsetNext = -0;
	        this.DefaultSettings_ = {
	            endingStart: ZeroCurvatureEnding,
	            endingEnd: ZeroCurvatureEnding
	        };
	    }
	}
	/**
	 * A basic linear interpolant.
	 *
	 * @augments Interpolant
	 */ class LinearInterpolant extends Interpolant {
	    interpolate_(i1, t0, t, t1) {
	        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset1 = i1 * stride, offset0 = offset1 - stride, weight1 = (t - t0) / (t1 - t0), weight0 = 1 - weight1;
	        for(let i = 0; i !== stride; ++i){
	            result[i] = values[offset0 + i] * weight0 + values[offset1 + i] * weight1;
	        }
	        return result;
	    }
	    /**
		 * Constructs a new linear interpolant.
		 *
		 * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
		 * @param {TypedArray} sampleValues - The sample values.
		 * @param {number} sampleSize - The sample size
		 * @param {TypedArray} [resultBuffer] - The result buffer.
		 */ constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
	        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
	    }
	}
	/**
	 * Interpolant that evaluates to the sample value at the position preceding
	 * the parameter.
	 *
	 * @augments Interpolant
	 */ class DiscreteInterpolant extends Interpolant {
	    interpolate_(i1 /*, t0, t, t1 */ ) {
	        return this.copySampleValue_(i1 - 1);
	    }
	    /**
		 * Constructs a new discrete interpolant.
		 *
		 * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
		 * @param {TypedArray} sampleValues - The sample values.
		 * @param {number} sampleSize - The sample size
		 * @param {TypedArray} [resultBuffer] - The result buffer.
		 */ constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
	        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
	    }
	}
	class KeyframeTrack {
	    // Serialization (in static context, because of constructor invocation
	    // and automatic invocation of .toJSON):
	    static toJSON(track) {
	        const trackType = track.constructor;
	        let json;
	        // derived classes can define a static toJSON method
	        if (trackType.toJSON !== this.toJSON) {
	            json = trackType.toJSON(track);
	        } else {
	            // by default, we assume the data can be serialized as-is
	            json = {
	                'name': track.name,
	                'times': convertArray(track.times, Array),
	                'values': convertArray(track.values, Array)
	            };
	            const interpolation = track.getInterpolation();
	            if (interpolation !== track.DefaultInterpolation) {
	                json.interpolation = interpolation;
	            }
	        }
	        json.type = track.ValueTypeName; // mandatory
	        return json;
	    }
	    InterpolantFactoryMethodDiscrete(result) {
	        return new DiscreteInterpolant(this.times, this.values, this.getValueSize(), result);
	    }
	    InterpolantFactoryMethodLinear(result) {
	        return new LinearInterpolant(this.times, this.values, this.getValueSize(), result);
	    }
	    InterpolantFactoryMethodSmooth(result) {
	        return new CubicInterpolant(this.times, this.values, this.getValueSize(), result);
	    }
	    setInterpolation(interpolation) {
	        let factoryMethod;
	        switch(interpolation){
	            case InterpolateDiscrete:
	                factoryMethod = this.InterpolantFactoryMethodDiscrete;
	                break;
	            case InterpolateLinear:
	                factoryMethod = this.InterpolantFactoryMethodLinear;
	                break;
	            case InterpolateSmooth:
	                factoryMethod = this.InterpolantFactoryMethodSmooth;
	                break;
	        }
	        if (factoryMethod === undefined) {
	            const message = 'unsupported interpolation for ' + this.ValueTypeName + ' keyframe track named ' + this.name;
	            if (this.createInterpolant === undefined) {
	                // fall back to default, unless the default itself is messed up
	                if (interpolation !== this.DefaultInterpolation) {
	                    this.setInterpolation(this.DefaultInterpolation);
	                } else {
	                    throw new Error(message); // fatal, in this case
	                }
	            }
	            console.warn('THREE.KeyframeTrack:', message);
	            return this;
	        }
	        this.createInterpolant = factoryMethod;
	        return this;
	    }
	    getInterpolation() {
	        switch(this.createInterpolant){
	            case this.InterpolantFactoryMethodDiscrete:
	                return InterpolateDiscrete;
	            case this.InterpolantFactoryMethodLinear:
	                return InterpolateLinear;
	            case this.InterpolantFactoryMethodSmooth:
	                return InterpolateSmooth;
	        }
	    }
	    getValueSize() {
	        return this.values.length / this.times.length;
	    }
	    // move all keyframes either forwards or backwards in time
	    shift(timeOffset) {
	        if (timeOffset !== 0.0) {
	            const times = this.times;
	            for(let i = 0, n = times.length; i !== n; ++i){
	                times[i] += timeOffset;
	            }
	        }
	        return this;
	    }
	    // scale all keyframe times by a factor (useful for frame <-> seconds conversions)
	    scale(timeScale) {
	        if (timeScale !== 1.0) {
	            const times = this.times;
	            for(let i = 0, n = times.length; i !== n; ++i){
	                times[i] *= timeScale;
	            }
	        }
	        return this;
	    }
	    // removes keyframes before and after animation without changing any values within the range [startTime, endTime].
	    // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
	    trim(startTime, endTime) {
	        const times = this.times, nKeys = times.length;
	        let from = 0, to = nKeys - 1;
	        while(from !== nKeys && times[from] < startTime){
	            ++from;
	        }
	        while(to !== -1 && times[to] > endTime){
	            --to;
	        }
	        ++to; // inclusive -> exclusive bound
	        if (from !== 0 || to !== nKeys) {
	            // empty tracks are forbidden, so keep at least one keyframe
	            if (from >= to) {
	                to = Math.max(to, 1);
	                from = to - 1;
	            }
	            const stride = this.getValueSize();
	            this.times = times.slice(from, to);
	            this.values = this.values.slice(from * stride, to * stride);
	        }
	        return this;
	    }
	    // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
	    validate() {
	        let valid = true;
	        const valueSize = this.getValueSize();
	        if (valueSize - Math.floor(valueSize) !== 0) {
	            console.error('THREE.KeyframeTrack: Invalid value size in track.', this);
	            valid = false;
	        }
	        const times = this.times, values = this.values, nKeys = times.length;
	        if (nKeys === 0) {
	            console.error('THREE.KeyframeTrack: Track is empty.', this);
	            valid = false;
	        }
	        let prevTime = null;
	        for(let i = 0; i !== nKeys; i++){
	            const currTime = times[i];
	            if (typeof currTime === 'number' && isNaN(currTime)) {
	                console.error('THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime);
	                valid = false;
	                break;
	            }
	            if (prevTime !== null && prevTime > currTime) {
	                console.error('THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime);
	                valid = false;
	                break;
	            }
	            prevTime = currTime;
	        }
	        if (values !== undefined) {
	            if (isTypedArray(values)) {
	                for(let i = 0, n = values.length; i !== n; ++i){
	                    const value = values[i];
	                    if (isNaN(value)) {
	                        console.error('THREE.KeyframeTrack: Value is not a valid number.', this, i, value);
	                        valid = false;
	                        break;
	                    }
	                }
	            }
	        }
	        return valid;
	    }
	    // removes equivalent sequential keys as common in morph target sequences
	    // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
	    optimize() {
	        // times or values may be shared with other tracks, so overwriting is unsafe
	        const times = this.times.slice(), values = this.values.slice(), stride = this.getValueSize(), smoothInterpolation = this.getInterpolation() === InterpolateSmooth, lastIndex = times.length - 1;
	        let writeIndex = 1;
	        for(let i = 1; i < lastIndex; ++i){
	            let keep = false;
	            const time = times[i];
	            const timeNext = times[i + 1];
	            // remove adjacent keyframes scheduled at the same time
	            if (time !== timeNext && (i !== 1 || time !== times[0])) {
	                if (!smoothInterpolation) {
	                    // remove unnecessary keyframes same as their neighbors
	                    const offset = i * stride, offsetP = offset - stride, offsetN = offset + stride;
	                    for(let j = 0; j !== stride; ++j){
	                        const value = values[offset + j];
	                        if (value !== values[offsetP + j] || value !== values[offsetN + j]) {
	                            keep = true;
	                            break;
	                        }
	                    }
	                } else {
	                    keep = true;
	                }
	            }
	            // in-place compaction
	            if (keep) {
	                if (i !== writeIndex) {
	                    times[writeIndex] = times[i];
	                    const readOffset = i * stride, writeOffset = writeIndex * stride;
	                    for(let j = 0; j !== stride; ++j){
	                        values[writeOffset + j] = values[readOffset + j];
	                    }
	                }
	                ++writeIndex;
	            }
	        }
	        // flush last keyframe (compaction looks ahead)
	        if (lastIndex > 0) {
	            times[writeIndex] = times[lastIndex];
	            for(let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++j){
	                values[writeOffset + j] = values[readOffset + j];
	            }
	            ++writeIndex;
	        }
	        if (writeIndex !== times.length) {
	            this.times = times.slice(0, writeIndex);
	            this.values = values.slice(0, writeIndex * stride);
	        } else {
	            this.times = times;
	            this.values = values;
	        }
	        return this;
	    }
	    clone() {
	        const times = this.times.slice();
	        const values = this.values.slice();
	        const TypedKeyframeTrack = this.constructor;
	        const track = new TypedKeyframeTrack(this.name, times, values);
	        // Interpolant argument to constructor is not saved, so copy the factory method directly.
	        track.createInterpolant = this.createInterpolant;
	        return track;
	    }
	    constructor(name, times, values, interpolation){
	        if (name === undefined) throw new Error('THREE.KeyframeTrack: track name is undefined');
	        if (times === undefined || times.length === 0) throw new Error('THREE.KeyframeTrack: no keyframes in track named ' + name);
	        this.name = name;
	        this.times = convertArray(times, this.TimeBufferType);
	        this.values = convertArray(values, this.ValueBufferType);
	        this.setInterpolation(interpolation || this.DefaultInterpolation);
	    }
	}
	KeyframeTrack.prototype.TimeBufferType = Float32Array;
	KeyframeTrack.prototype.ValueBufferType = Float32Array;
	KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;
	/**
	 * A Track of Boolean keyframe values.
	 */ class BooleanKeyframeTrack extends KeyframeTrack {
	    // No interpolation parameter because only InterpolateDiscrete is valid.
	    constructor(name, times, values){
	        super(name, times, values);
	    }
	}
	BooleanKeyframeTrack.prototype.ValueTypeName = 'bool';
	BooleanKeyframeTrack.prototype.ValueBufferType = Array;
	BooleanKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
	BooleanKeyframeTrack.prototype.InterpolantFactoryMethodLinear = undefined;
	BooleanKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;
	/**
	 * A Track of keyframe values that represent color.
	 */ class ColorKeyframeTrack extends KeyframeTrack {
	}
	ColorKeyframeTrack.prototype.ValueTypeName = 'color';
	/**
	 * A Track of numeric keyframe values.
	 */ class NumberKeyframeTrack extends KeyframeTrack {
	}
	NumberKeyframeTrack.prototype.ValueTypeName = 'number';
	/**
	 * Spherical linear unit quaternion interpolant.
	 *
	 * @augments Interpolant
	 */ class QuaternionLinearInterpolant extends Interpolant {
	    interpolate_(i1, t0, t, t1) {
	        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, alpha = (t - t0) / (t1 - t0);
	        let offset = i1 * stride;
	        for(let end = offset + stride; offset !== end; offset += 4){
	            Quaternion.slerpFlat(result, 0, values, offset - stride, values, offset, alpha);
	        }
	        return result;
	    }
	    /**
		 * Constructs a new SLERP interpolant.
		 *
		 * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
		 * @param {TypedArray} sampleValues - The sample values.
		 * @param {number} sampleSize - The sample size
		 * @param {TypedArray} [resultBuffer] - The result buffer.
		 */ constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
	        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
	    }
	}
	/**
	 * A Track of quaternion keyframe values.
	 */ class QuaternionKeyframeTrack extends KeyframeTrack {
	    InterpolantFactoryMethodLinear(result) {
	        return new QuaternionLinearInterpolant(this.times, this.values, this.getValueSize(), result);
	    }
	}
	QuaternionKeyframeTrack.prototype.ValueTypeName = 'quaternion';
	// ValueBufferType is inherited
	// DefaultInterpolation is inherited;
	QuaternionKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;
	/**
	 * A Track that interpolates Strings
	 */ class StringKeyframeTrack extends KeyframeTrack {
	    // No interpolation parameter because only InterpolateDiscrete is valid.
	    constructor(name, times, values){
	        super(name, times, values);
	    }
	}
	StringKeyframeTrack.prototype.ValueTypeName = 'string';
	StringKeyframeTrack.prototype.ValueBufferType = Array;
	StringKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
	StringKeyframeTrack.prototype.InterpolantFactoryMethodLinear = undefined;
	StringKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = undefined;
	/**
	 * A Track of vectored keyframe values.
	 */ class VectorKeyframeTrack extends KeyframeTrack {
	}
	VectorKeyframeTrack.prototype.ValueTypeName = 'vector';
	class AnimationClip {
	    static parse(json) {
	        const tracks = [], jsonTracks = json.tracks, frameTime = 1.0 / (json.fps || 1.0);
	        for(let i = 0, n = jsonTracks.length; i !== n; ++i){
	            tracks.push(parseKeyframeTrack(jsonTracks[i]).scale(frameTime));
	        }
	        const clip = new this(json.name, json.duration, tracks, json.blendMode);
	        clip.uuid = json.uuid;
	        return clip;
	    }
	    static toJSON(clip) {
	        const tracks = [], clipTracks = clip.tracks;
	        const json = {
	            'name': clip.name,
	            'duration': clip.duration,
	            'tracks': tracks,
	            'uuid': clip.uuid,
	            'blendMode': clip.blendMode
	        };
	        for(let i = 0, n = clipTracks.length; i !== n; ++i){
	            tracks.push(KeyframeTrack.toJSON(clipTracks[i]));
	        }
	        return json;
	    }
	    static CreateFromMorphTargetSequence(name, morphTargetSequence, fps, noLoop) {
	        const numMorphTargets = morphTargetSequence.length;
	        const tracks = [];
	        for(let i = 0; i < numMorphTargets; i++){
	            let times = [];
	            let values = [];
	            times.push((i + numMorphTargets - 1) % numMorphTargets, i, (i + 1) % numMorphTargets);
	            values.push(0, 1, 0);
	            const order = getKeyframeOrder(times);
	            times = sortedArray(times, 1, order);
	            values = sortedArray(values, 1, order);
	            // if there is a key at the first frame, duplicate it as the
	            // last frame as well for perfect loop.
	            if (!noLoop && times[0] === 0) {
	                times.push(numMorphTargets);
	                values.push(values[0]);
	            }
	            tracks.push(new NumberKeyframeTrack('.morphTargetInfluences[' + morphTargetSequence[i].name + ']', times, values).scale(1.0 / fps));
	        }
	        return new this(name, -1, tracks);
	    }
	    static findByName(objectOrClipArray, name) {
	        let clipArray = objectOrClipArray;
	        if (!Array.isArray(objectOrClipArray)) {
	            const o = objectOrClipArray;
	            clipArray = o.geometry && o.geometry.animations || o.animations;
	        }
	        for(let i = 0; i < clipArray.length; i++){
	            if (clipArray[i].name === name) {
	                return clipArray[i];
	            }
	        }
	        return null;
	    }
	    static CreateClipsFromMorphTargetSequences(morphTargets, fps, noLoop) {
	        const animationToMorphTargets = {};
	        // tested with https://regex101.com/ on trick sequences
	        // such flamingo_flyA_003, flamingo_run1_003, crdeath0059
	        const pattern = /^([\w-]*?)([\d]+)$/;
	        // sort morph target names into animation groups based
	        // patterns like Walk_001, Walk_002, Run_001, Run_002
	        for(let i = 0, il = morphTargets.length; i < il; i++){
	            const morphTarget = morphTargets[i];
	            const parts = morphTarget.name.match(pattern);
	            if (parts && parts.length > 1) {
	                const name = parts[1];
	                let animationMorphTargets = animationToMorphTargets[name];
	                if (!animationMorphTargets) {
	                    animationToMorphTargets[name] = animationMorphTargets = [];
	                }
	                animationMorphTargets.push(morphTarget);
	            }
	        }
	        const clips = [];
	        for(const name in animationToMorphTargets){
	            clips.push(this.CreateFromMorphTargetSequence(name, animationToMorphTargets[name], fps, noLoop));
	        }
	        return clips;
	    }
	    // parse the animation.hierarchy format
	    static parseAnimation(animation, bones) {
	        if (!animation) {
	            console.error('THREE.AnimationClip: No animation in JSONLoader data.');
	            return null;
	        }
	        const addNonemptyTrack = function(trackType, trackName, animationKeys, propertyName, destTracks) {
	            // only return track if there are actually keys.
	            if (animationKeys.length !== 0) {
	                const times = [];
	                const values = [];
	                flattenJSON(animationKeys, times, values, propertyName);
	                // empty keys are filtered out, so check again
	                if (times.length !== 0) {
	                    destTracks.push(new trackType(trackName, times, values));
	                }
	            }
	        };
	        const tracks = [];
	        const clipName = animation.name || 'default';
	        const fps = animation.fps || 30;
	        const blendMode = animation.blendMode;
	        // automatic length determination in AnimationClip.
	        let duration = animation.length || -1;
	        const hierarchyTracks = animation.hierarchy || [];
	        for(let h = 0; h < hierarchyTracks.length; h++){
	            const animationKeys = hierarchyTracks[h].keys;
	            // skip empty tracks
	            if (!animationKeys || animationKeys.length === 0) continue;
	            // process morph targets
	            if (animationKeys[0].morphTargets) {
	                // figure out all morph targets used in this track
	                const morphTargetNames = {};
	                let k;
	                for(k = 0; k < animationKeys.length; k++){
	                    if (animationKeys[k].morphTargets) {
	                        for(let m = 0; m < animationKeys[k].morphTargets.length; m++){
	                            morphTargetNames[animationKeys[k].morphTargets[m]] = -1;
	                        }
	                    }
	                }
	                // create a track for each morph target with all zero
	                // morphTargetInfluences except for the keys in which
	                // the morphTarget is named.
	                for(const morphTargetName in morphTargetNames){
	                    const times = [];
	                    const values = [];
	                    for(let m = 0; m !== animationKeys[k].morphTargets.length; ++m){
	                        const animationKey = animationKeys[k];
	                        times.push(animationKey.time);
	                        values.push(animationKey.morphTarget === morphTargetName ? 1 : 0);
	                    }
	                    tracks.push(new NumberKeyframeTrack('.morphTargetInfluence[' + morphTargetName + ']', times, values));
	                }
	                duration = morphTargetNames.length * fps;
	            } else {
	                // ...assume skeletal animation
	                const boneName = '.bones[' + bones[h].name + ']';
	                addNonemptyTrack(VectorKeyframeTrack, boneName + '.position', animationKeys, 'pos', tracks);
	                addNonemptyTrack(QuaternionKeyframeTrack, boneName + '.quaternion', animationKeys, 'rot', tracks);
	                addNonemptyTrack(VectorKeyframeTrack, boneName + '.scale', animationKeys, 'scl', tracks);
	            }
	        }
	        if (tracks.length === 0) {
	            return null;
	        }
	        const clip = new this(clipName, duration, tracks, blendMode);
	        return clip;
	    }
	    resetDuration() {
	        const tracks = this.tracks;
	        let duration = 0;
	        for(let i = 0, n = tracks.length; i !== n; ++i){
	            const track = this.tracks[i];
	            duration = Math.max(duration, track.times[track.times.length - 1]);
	        }
	        this.duration = duration;
	        return this;
	    }
	    trim() {
	        for(let i = 0; i < this.tracks.length; i++){
	            this.tracks[i].trim(0, this.duration);
	        }
	        return this;
	    }
	    validate() {
	        let valid = true;
	        for(let i = 0; i < this.tracks.length; i++){
	            valid = valid && this.tracks[i].validate();
	        }
	        return valid;
	    }
	    optimize() {
	        for(let i = 0; i < this.tracks.length; i++){
	            this.tracks[i].optimize();
	        }
	        return this;
	    }
	    clone() {
	        const tracks = [];
	        for(let i = 0; i < this.tracks.length; i++){
	            tracks.push(this.tracks[i].clone());
	        }
	        return new this.constructor(this.name, this.duration, tracks, this.blendMode);
	    }
	    toJSON() {
	        return this.constructor.toJSON(this);
	    }
	    constructor(name = '', duration = -1, tracks = [], blendMode = NormalAnimationBlendMode){
	        this.name = name;
	        this.tracks = tracks;
	        this.duration = duration;
	        this.blendMode = blendMode;
	        this.uuid = generateUUID();
	        // this means it should figure out its duration by scanning the tracks
	        if (this.duration < 0) {
	            this.resetDuration();
	        }
	    }
	}
	function getTrackTypeForValueTypeName(typeName) {
	    switch(typeName.toLowerCase()){
	        case 'scalar':
	        case 'double':
	        case 'float':
	        case 'number':
	        case 'integer':
	            return NumberKeyframeTrack;
	        case 'vector':
	        case 'vector2':
	        case 'vector3':
	        case 'vector4':
	            return VectorKeyframeTrack;
	        case 'color':
	            return ColorKeyframeTrack;
	        case 'quaternion':
	            return QuaternionKeyframeTrack;
	        case 'bool':
	        case 'boolean':
	            return BooleanKeyframeTrack;
	        case 'string':
	            return StringKeyframeTrack;
	    }
	    throw new Error('THREE.KeyframeTrack: Unsupported typeName: ' + typeName);
	}
	function parseKeyframeTrack(json) {
	    if (json.type === undefined) {
	        throw new Error('THREE.KeyframeTrack: track type undefined, can not parse');
	    }
	    const trackType = getTrackTypeForValueTypeName(json.type);
	    if (json.times === undefined) {
	        const times = [], values = [];
	        flattenJSON(json.keys, times, values, 'value');
	        json.times = times;
	        json.values = values;
	    }
	    // derived classes can define a static parse method
	    if (trackType.parse !== undefined) {
	        return trackType.parse(json);
	    } else {
	        // by default, we assume a constructor compatible with the base
	        return new trackType(json.name, json.times, json.values, json.interpolation);
	    }
	}
	const Cache = {
	    enabled: false,
	    files: {},
	    add: function(key, file) {
	        if (this.enabled === false) return;
	        // console.log( 'THREE.Cache', 'Adding key:', key );
	        this.files[key] = file;
	    },
	    get: function(key) {
	        if (this.enabled === false) return;
	        // console.log( 'THREE.Cache', 'Checking key:', key );
	        return this.files[key];
	    },
	    remove: function(key) {
	        delete this.files[key];
	    },
	    clear: function() {
	        this.files = {};
	    }
	};
	class LoadingManager {
	    constructor(onLoad, onProgress, onError){
	        const scope = this;
	        let isLoading = false;
	        let itemsLoaded = 0;
	        let itemsTotal = 0;
	        let urlModifier = undefined;
	        const handlers = [];
	        // Refer to #5689 for the reason why we don't set .onStart
	        // in the constructor
	        this.onStart = undefined;
	        this.onLoad = onLoad;
	        this.onProgress = onProgress;
	        this.onError = onError;
	        this.itemStart = function(url) {
	            itemsTotal++;
	            if (isLoading === false) {
	                if (scope.onStart !== undefined) {
	                    scope.onStart(url, itemsLoaded, itemsTotal);
	                }
	            }
	            isLoading = true;
	        };
	        this.itemEnd = function(url) {
	            itemsLoaded++;
	            if (scope.onProgress !== undefined) {
	                scope.onProgress(url, itemsLoaded, itemsTotal);
	            }
	            if (itemsLoaded === itemsTotal) {
	                isLoading = false;
	                if (scope.onLoad !== undefined) {
	                    scope.onLoad();
	                }
	            }
	        };
	        this.itemError = function(url) {
	            if (scope.onError !== undefined) {
	                scope.onError(url);
	            }
	        };
	        this.resolveURL = function(url) {
	            if (urlModifier) {
	                return urlModifier(url);
	            }
	            return url;
	        };
	        this.setURLModifier = function(transform) {
	            urlModifier = transform;
	            return this;
	        };
	        this.addHandler = function(regex, loader) {
	            handlers.push(regex, loader);
	            return this;
	        };
	        this.removeHandler = function(regex) {
	            const index = handlers.indexOf(regex);
	            if (index !== -1) {
	                handlers.splice(index, 2);
	            }
	            return this;
	        };
	        this.getHandler = function(file) {
	            for(let i = 0, l = handlers.length; i < l; i += 2){
	                const regex = handlers[i];
	                const loader = handlers[i + 1];
	                if (regex.global) regex.lastIndex = 0; // see #17920
	                if (regex.test(file)) {
	                    return loader;
	                }
	            }
	            return null;
	        };
	    }
	}
	const DefaultLoadingManager = /*@__PURE__*/ new LoadingManager();
	/**
	 * Abstract base class for loaders.
	 *
	 * @abstract
	 */ class Loader {
	    /**
		 * This method needs to be implemented by all concrete loaders. It holds the
		 * logic for loading assets from the backend.
		 *
		 * @param {string} url - The path/URL of the file to be loaded.
		 * @param {Function} onLoad - Executed when the loading process has been finished.
		 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
		 * @param {onErrorCallback} onError - Executed when errors occur.
		 */ load() {}
	    /**
		 * A async version of {@link Loader#load}.
		 *
		 * @param {string} url - The path/URL of the file to be loaded.
		 * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
		 * @return {Promise} A Promise that resolves when the asset has been loaded.
		 */ loadAsync(url, onProgress) {
	        const scope = this;
	        return new Promise(function(resolve, reject) {
	            scope.load(url, resolve, onProgress, reject);
	        });
	    }
	    /**
		 * This method needs to be implemented by all concrete loaders. It holds the
		 * logic for parsing the asset into three.js entities.
		 *
		 * @param {any} data - The data to parse.
		 */ parse() {}
	    /**
		 * Sets the `crossOrigin` String to implement CORS for loading the URL
		 * from a different domain that allows CORS.
		 *
		 * @param {string} crossOrigin - The `crossOrigin` value.
		 * @return {Loader} A reference to this instance.
		 */ setCrossOrigin(crossOrigin) {
	        this.crossOrigin = crossOrigin;
	        return this;
	    }
	    /**
		 * Whether the XMLHttpRequest uses credentials such as cookies, authorization
		 * headers or TLS client certificates, see [XMLHttpRequest.withCredentials]{@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials}.
		 *
		 * Note: This setting has no effect if you are loading files locally or from the same domain.
		 *
		 * @param {boolean} value - The `withCredentials` value.
		 * @return {Loader} A reference to this instance.
		 */ setWithCredentials(value) {
	        this.withCredentials = value;
	        return this;
	    }
	    /**
		 * Sets the base path for the asset.
		 *
		 * @param {string} path - The base path.
		 * @return {Loader} A reference to this instance.
		 */ setPath(path) {
	        this.path = path;
	        return this;
	    }
	    /**
		 * Sets the base path for dependent resources like textures.
		 *
		 * @param {string} resourcePath - The resource path.
		 * @return {Loader} A reference to this instance.
		 */ setResourcePath(resourcePath) {
	        this.resourcePath = resourcePath;
	        return this;
	    }
	    /**
		 * Sets the given request header.
		 *
		 * @param {Object} requestHeader - A [request header]{@link https://developer.mozilla.org/en-US/docs/Glossary/Request_header}
		 * for configuring the HTTP request.
		 * @return {Loader} A reference to this instance.
		 */ setRequestHeader(requestHeader) {
	        this.requestHeader = requestHeader;
	        return this;
	    }
	    /**
		 * Constructs a new loader.
		 *
		 * @param {LoadingManager} [manager] - The loading manager.
		 */ constructor(manager){
	        /**
			 * The loading manager.
			 *
			 * @type {LoadingManager}
			 * @default DefaultLoadingManager
			 */ this.manager = manager !== undefined ? manager : DefaultLoadingManager;
	        /**
			 * The crossOrigin string to implement CORS for loading the url from a
			 * different domain that allows CORS.
			 *
			 * @type {string}
			 * @default 'anonymous'
			 */ this.crossOrigin = 'anonymous';
	        /**
			 * Whether the XMLHttpRequest uses credentials.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.withCredentials = false;
	        /**
			 * The base path from which the asset will be loaded.
			 *
			 * @type {string}
			 */ this.path = '';
	        /**
			 * The base path from which additional resources like textures will be loaded.
			 *
			 * @type {string}
			 */ this.resourcePath = '';
	        /**
			 * The [request header]{@link https://developer.mozilla.org/en-US/docs/Glossary/Request_header}
			 * used in HTTP request.
			 *
			 * @type {Object}
			 */ this.requestHeader = {};
	    }
	}
	/**
	 * Callback for onProgress in loaders.
	 *
	 *
	 * @callback onProgressCallback
	 * @param {ProgressEvent} event - An instance of `ProgressEvent` that represents the current loading status.
	 */ /**
	 * Callback for onError in loaders.
	 *
	 *
	 * @callback onErrorCallback
	 * @param {Error} error - The error which occurred during the loading process.
	 */ /**
	 * The default material name that is used by loaders
	 * when creating materials for loaded 3D objects.
	 *
	 * Note: Not all loaders might honor this setting.
	 *
	 * @static
	 * @type {string}
	 * @default '__DEFAULT'
	 */ Loader.DEFAULT_MATERIAL_NAME = '__DEFAULT';
	const loading = {};
	class HttpError extends Error {
	    constructor(message, response){
	        super(message);
	        this.response = response;
	    }
	}
	class FileLoader extends Loader {
	    load(url, onLoad, onProgress, onError) {
	        if (url === undefined) url = '';
	        if (this.path !== undefined) url = this.path + url;
	        url = this.manager.resolveURL(url);
	        const cached = Cache.get(url);
	        if (cached !== undefined) {
	            this.manager.itemStart(url);
	            setTimeout(()=>{
	                if (onLoad) onLoad(cached);
	                this.manager.itemEnd(url);
	            }, 0);
	            return cached;
	        }
	        // Check if request is duplicate
	        if (loading[url] !== undefined) {
	            loading[url].push({
	                onLoad: onLoad,
	                onProgress: onProgress,
	                onError: onError
	            });
	            return;
	        }
	        // Initialise array for duplicate requests
	        loading[url] = [];
	        loading[url].push({
	            onLoad: onLoad,
	            onProgress: onProgress,
	            onError: onError
	        });
	        // create request
	        const req = new Request(url, {
	            headers: new Headers(this.requestHeader),
	            credentials: this.withCredentials ? 'include' : 'same-origin'
	        });
	        // record states ( avoid data race )
	        const mimeType = this.mimeType;
	        const responseType = this.responseType;
	        // start the fetch
	        fetch(req).then((response)=>{
	            if (response.status === 200 || response.status === 0) {
	                // Some browsers return HTTP Status 0 when using non-http protocol
	                // e.g. 'file://' or 'data://'. Handle as success.
	                if (response.status === 0) {
	                    console.warn('THREE.FileLoader: HTTP Status 0 received.');
	                }
	                // Workaround: Checking if response.body === undefined for Alipay browser #23548
	                if (typeof ReadableStream === 'undefined' || response.body === undefined || response.body.getReader === undefined) {
	                    return response;
	                }
	                const callbacks = loading[url];
	                const reader = response.body.getReader();
	                // Nginx needs X-File-Size check
	                // https://serverfault.com/questions/482875/why-does-nginx-remove-content-length-header-for-chunked-content
	                const contentLength = response.headers.get('X-File-Size') || response.headers.get('Content-Length');
	                const total = contentLength ? parseInt(contentLength) : 0;
	                const lengthComputable = total !== 0;
	                let loaded = 0;
	                // periodically read data into the new stream tracking while download progress
	                const stream = new ReadableStream({
	                    start (controller) {
	                        readData();
	                        function readData() {
	                            reader.read().then(({ done, value })=>{
	                                if (done) {
	                                    controller.close();
	                                } else {
	                                    loaded += value.byteLength;
	                                    const event = new ProgressEvent('progress', {
	                                        lengthComputable,
	                                        loaded,
	                                        total
	                                    });
	                                    for(let i = 0, il = callbacks.length; i < il; i++){
	                                        const callback = callbacks[i];
	                                        if (callback.onProgress) callback.onProgress(event);
	                                    }
	                                    controller.enqueue(value);
	                                    readData();
	                                }
	                            }, (e)=>{
	                                controller.error(e);
	                            });
	                        }
	                    }
	                });
	                return new Response(stream);
	            } else {
	                throw new HttpError(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`, response);
	            }
	        }).then((response)=>{
	            switch(responseType){
	                case 'arraybuffer':
	                    return response.arrayBuffer();
	                case 'blob':
	                    return response.blob();
	                case 'document':
	                    return response.text().then((text)=>{
	                        const parser = new DOMParser();
	                        return parser.parseFromString(text, mimeType);
	                    });
	                case 'json':
	                    return response.json();
	                default:
	                    if (mimeType === undefined) {
	                        return response.text();
	                    } else {
	                        // sniff encoding
	                        const re = /charset="?([^;"\s]*)"?/i;
	                        const exec = re.exec(mimeType);
	                        const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
	                        const decoder = new TextDecoder(label);
	                        return response.arrayBuffer().then((ab)=>decoder.decode(ab));
	                    }
	            }
	        }).then((data)=>{
	            // Add to cache only on HTTP success, so that we do not cache
	            // error response bodies as proper responses to requests.
	            Cache.add(url, data);
	            const callbacks = loading[url];
	            delete loading[url];
	            for(let i = 0, il = callbacks.length; i < il; i++){
	                const callback = callbacks[i];
	                if (callback.onLoad) callback.onLoad(data);
	            }
	        }).catch((err)=>{
	            // Abort errors and other errors are handled the same
	            const callbacks = loading[url];
	            if (callbacks === undefined) {
	                // When onLoad was called and url was deleted in `loading`
	                this.manager.itemError(url);
	                throw err;
	            }
	            delete loading[url];
	            for(let i = 0, il = callbacks.length; i < il; i++){
	                const callback = callbacks[i];
	                if (callback.onError) callback.onError(err);
	            }
	            this.manager.itemError(url);
	        }).finally(()=>{
	            this.manager.itemEnd(url);
	        });
	        this.manager.itemStart(url);
	    }
	    setResponseType(value) {
	        this.responseType = value;
	        return this;
	    }
	    setMimeType(value) {
	        this.mimeType = value;
	        return this;
	    }
	    constructor(manager){
	        super(manager);
	    }
	}
	class ImageLoader extends Loader {
	    load(url, onLoad, onProgress, onError) {
	        if (this.path !== undefined) url = this.path + url;
	        url = this.manager.resolveURL(url);
	        const scope = this;
	        const cached = Cache.get(url);
	        if (cached !== undefined) {
	            scope.manager.itemStart(url);
	            setTimeout(function() {
	                if (onLoad) onLoad(cached);
	                scope.manager.itemEnd(url);
	            }, 0);
	            return cached;
	        }
	        const image = createElementNS('img');
	        function onImageLoad() {
	            removeEventListeners();
	            Cache.add(url, this);
	            if (onLoad) onLoad(this);
	            scope.manager.itemEnd(url);
	        }
	        function onImageError(event) {
	            removeEventListeners();
	            if (onError) onError(event);
	            scope.manager.itemError(url);
	            scope.manager.itemEnd(url);
	        }
	        function removeEventListeners() {
	            image.removeEventListener('load', onImageLoad, false);
	            image.removeEventListener('error', onImageError, false);
	        }
	        image.addEventListener('load', onImageLoad, false);
	        image.addEventListener('error', onImageError, false);
	        if (url.slice(0, 5) !== 'data:') {
	            if (this.crossOrigin !== undefined) image.crossOrigin = this.crossOrigin;
	        }
	        scope.manager.itemStart(url);
	        image.src = url;
	        return image;
	    }
	    constructor(manager){
	        super(manager);
	    }
	}
	/**
	 * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
	 *
	 * Sub classes have to implement the parse() method which will be used in load().
	 */ class DataTextureLoader extends Loader {
	    load(url, onLoad, onProgress, onError) {
	        const scope = this;
	        const texture = new DataTexture();
	        const loader = new FileLoader(this.manager);
	        loader.setResponseType('arraybuffer');
	        loader.setRequestHeader(this.requestHeader);
	        loader.setPath(this.path);
	        loader.setWithCredentials(scope.withCredentials);
	        loader.load(url, function(buffer) {
	            let texData;
	            try {
	                texData = scope.parse(buffer);
	            } catch (error) {
	                if (onError !== undefined) {
	                    onError(error);
	                } else {
	                    console.error(error);
	                    return;
	                }
	            }
	            if (texData.image !== undefined) {
	                texture.image = texData.image;
	            } else if (texData.data !== undefined) {
	                texture.image.width = texData.width;
	                texture.image.height = texData.height;
	                texture.image.data = texData.data;
	            }
	            texture.wrapS = texData.wrapS !== undefined ? texData.wrapS : ClampToEdgeWrapping;
	            texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : ClampToEdgeWrapping;
	            texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : LinearFilter;
	            texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : LinearFilter;
	            texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;
	            if (texData.colorSpace !== undefined) {
	                texture.colorSpace = texData.colorSpace;
	            }
	            if (texData.flipY !== undefined) {
	                texture.flipY = texData.flipY;
	            }
	            if (texData.format !== undefined) {
	                texture.format = texData.format;
	            }
	            if (texData.type !== undefined) {
	                texture.type = texData.type;
	            }
	            if (texData.mipmaps !== undefined) {
	                texture.mipmaps = texData.mipmaps;
	                texture.minFilter = LinearMipmapLinearFilter; // presumably...
	            }
	            if (texData.mipmapCount === 1) {
	                texture.minFilter = LinearFilter;
	            }
	            if (texData.generateMipmaps !== undefined) {
	                texture.generateMipmaps = texData.generateMipmaps;
	            }
	            texture.needsUpdate = true;
	            if (onLoad) onLoad(texture, texData);
	        }, onProgress, onError);
	        return texture;
	    }
	    constructor(manager){
	        super(manager);
	    }
	}
	class TextureLoader extends Loader {
	    load(url, onLoad, onProgress, onError) {
	        const texture = new Texture$1();
	        const loader = new ImageLoader(this.manager);
	        loader.setCrossOrigin(this.crossOrigin);
	        loader.setPath(this.path);
	        loader.load(url, function(image) {
	            texture.image = image;
	            texture.needsUpdate = true;
	            if (onLoad !== undefined) {
	                onLoad(texture);
	            }
	        }, onProgress, onError);
	        return texture;
	    }
	    constructor(manager){
	        super(manager);
	    }
	}
	/**
	 * Abstract base class for lights - all other light types inherit the
	 * properties and methods described here.
	 *
	 * @abstract
	 * @augments Object3D
	 */ class Light extends Object3D {
	    /**
		 * Frees the GPU-related resources allocated by this instance. Call this
		 * method whenever this instance is no longer used in your app.
		 */ dispose() {
	    // Empty here in base class; some subclasses override.
	    }
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.color.copy(source.color);
	        this.intensity = source.intensity;
	        return this;
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        data.object.color = this.color.getHex();
	        data.object.intensity = this.intensity;
	        if (this.groundColor !== undefined) data.object.groundColor = this.groundColor.getHex();
	        if (this.distance !== undefined) data.object.distance = this.distance;
	        if (this.angle !== undefined) data.object.angle = this.angle;
	        if (this.decay !== undefined) data.object.decay = this.decay;
	        if (this.penumbra !== undefined) data.object.penumbra = this.penumbra;
	        if (this.shadow !== undefined) data.object.shadow = this.shadow.toJSON();
	        if (this.target !== undefined) data.object.target = this.target.uuid;
	        return data;
	    }
	    /**
		 * Constructs a new light.
		 *
		 * @param {(number|Color|string)} [color=0xffffff] - The light's color.
		 * @param {number} [intensity=1] - The light's strength/intensity.
		 */ constructor(color, intensity = 1){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isLight = true;
	        this.type = 'Light';
	        /**
			 * The light's color.
			 *
			 * @type {Color}
			 */ this.color = new Color(color);
	        /**
			 * The light's intensity.
			 *
			 * @type {number}
			 * @default 1
			 */ this.intensity = intensity;
	    }
	}
	const _projScreenMatrix$1 = /*@__PURE__*/ new Matrix4();
	const _lightPositionWorld$1 = /*@__PURE__*/ new Vector3();
	const _lookTarget$1 = /*@__PURE__*/ new Vector3();
	/**
	 * Abstract base class for light shadow classes. These classes
	 * represent the shadow configuration for different ligth types.
	 *
	 * @abstract
	 */ class LightShadow {
	    /**
		 * Used internally by the renderer to get the number of viewports that need
		 * to be rendered for this shadow.
		 *
		 * @return {number} The viewport count.
		 */ getViewportCount() {
	        return this._viewportCount;
	    }
	    /**
		 * Gets the shadow cameras frustum. Used internally by the renderer to cull objects.
		 *
		 * @return {Frustum} The shadow camera frustum.
		 */ getFrustum() {
	        return this._frustum;
	    }
	    /**
		 * Update the matrices for the camera and shadow, used internally by the renderer.
		 *
		 * @param {Light} light - The light for which the shadow is being rendered.
		 */ updateMatrices(light) {
	        const shadowCamera = this.camera;
	        const shadowMatrix = this.matrix;
	        _lightPositionWorld$1.setFromMatrixPosition(light.matrixWorld);
	        shadowCamera.position.copy(_lightPositionWorld$1);
	        _lookTarget$1.setFromMatrixPosition(light.target.matrixWorld);
	        shadowCamera.lookAt(_lookTarget$1);
	        shadowCamera.updateMatrixWorld();
	        _projScreenMatrix$1.multiplyMatrices(shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse);
	        this._frustum.setFromProjectionMatrix(_projScreenMatrix$1);
	        shadowMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
	        shadowMatrix.multiply(_projScreenMatrix$1);
	    }
	    /**
		 * Returns a viewport definition for the given viewport index.
		 *
		 * @param {number} viewportIndex - The viewport index.
		 * @return {Vector4} The viewport.
		 */ getViewport(viewportIndex) {
	        return this._viewports[viewportIndex];
	    }
	    /**
		 * Returns the frame extends.
		 *
		 * @return {Vector2} The frame extends.
		 */ getFrameExtents() {
	        return this._frameExtents;
	    }
	    /**
		 * Frees the GPU-related resources allocated by this instance. Call this
		 * method whenever this instance is no longer used in your app.
		 */ dispose() {
	        if (this.map) {
	            this.map.dispose();
	        }
	        if (this.mapPass) {
	            this.mapPass.dispose();
	        }
	    }
	    /**
		 * Copies the values of the given light shadow instance to this instance.
		 *
		 * @param {LightShadow} source - The light shadow to copy.
		 * @return {LightShadow} A reference to this light shadow instance.
		 */ copy(source) {
	        this.camera = source.camera.clone();
	        this.intensity = source.intensity;
	        this.bias = source.bias;
	        this.radius = source.radius;
	        this.mapSize.copy(source.mapSize);
	        return this;
	    }
	    /**
		 * Returns a new light shadow instance with copied values from this instance.
		 *
		 * @return {LightShadow} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Serializes the light shadow into JSON.
		 *
		 * @return {Object} A JSON object representing the serialized light shadow.
		 * @see {@link ObjectLoader#parse}
		 */ toJSON() {
	        const object = {};
	        if (this.intensity !== 1) object.intensity = this.intensity;
	        if (this.bias !== 0) object.bias = this.bias;
	        if (this.normalBias !== 0) object.normalBias = this.normalBias;
	        if (this.radius !== 1) object.radius = this.radius;
	        if (this.mapSize.x !== 512 || this.mapSize.y !== 512) object.mapSize = this.mapSize.toArray();
	        object.camera = this.camera.toJSON(false).object;
	        delete object.camera.matrix;
	        return object;
	    }
	    /**
		 * Constructs a new light shadow.
		 *
		 * @param {Camera} camera - The light's view of the world.
		 */ constructor(camera){
	        /**
			 * The light's view of the world.
			 *
			 * @type {Camera}
			 */ this.camera = camera;
	        /**
			 * The intensity of the shadow. The default is `1`.
			 * Valid values are in the range `[0, 1]`.
			 *
			 * @type {number}
			 * @default 1
			 */ this.intensity = 1;
	        /**
			 * Shadow map bias, how much to add or subtract from the normalized depth
			 * when deciding whether a surface is in shadow.
			 *
			 * The default is `0`. Very tiny adjustments here (in the order of `0.0001`)
			 * may help reduce artifacts in shadows.
			 *
			 * @type {number}
			 * @default 0
			 */ this.bias = 0;
	        /**
			 * Defines how much the position used to query the shadow map is offset along
			 * the object normal. The default is `0`. Increasing this value can be used to
			 * reduce shadow acne especially in large scenes where light shines onto
			 * geometry at a shallow angle. The cost is that shadows may appear distorted.
			 *
			 * @type {number}
			 * @default 0
			 */ this.normalBias = 0;
	        /**
			 * Setting this to values greater than 1 will blur the edges of the shadow.
			 * High values will cause unwanted banding effects in the shadows - a greater
			 * map size will allow for a higher value to be used here before these effects
			 * become visible.
			 *
			 * The property has no effect when the shadow map type is `PCFSoftShadowMap` and
			 * and it is recommended to increase softness by decreasing the shadow map size instead.
			 *
			 * The property has no effect when the shadow map type is `BasicShadowMap`.
			 *
			 * @type {number}
			 * @default 1
			 */ this.radius = 1;
	        /**
			 * The amount of samples to use when blurring a VSM shadow map.
			 *
			 * @type {number}
			 * @default 8
			 */ this.blurSamples = 8;
	        /**
			 * Defines the width and height of the shadow map. Higher values give better quality
			 * shadows at the cost of computation time. Values must be powers of two.
			 *
			 * @type {Vector2}
			 * @default (512,512)
			 */ this.mapSize = new Vector2(512, 512);
	        /**
			 * The depth map generated using the internal camera; a location beyond a
			 * pixel's depth is in shadow. Computed internally during rendering.
			 *
			 * @type {?RenderTarget}
			 * @default null
			 */ this.map = null;
	        /**
			 * The distribution map generated using the internal camera; an occlusion is
			 * calculated based on the distribution of depths. Computed internally during
			 * rendering.
			 *
			 * @type {?RenderTarget}
			 * @default null
			 */ this.mapPass = null;
	        /**
			 * Model to shadow camera space, to compute location and depth in shadow map.
			 * This is computed internally during rendering.
			 *
			 * @type {Matrix4}
			 */ this.matrix = new Matrix4();
	        /**
			 * Enables automatic updates of the light's shadow. If you do not require dynamic
			 * lighting / shadows, you may set this to `false`.
			 *
			 * @type {boolean}
			 * @default true
			 */ this.autoUpdate = true;
	        /**
			 * When set to `true`, shadow maps will be updated in the next `render` call.
			 * If you have set {@link LightShadow#autoUpdate} to `false`, you will need to
			 * set this property to `true` and then make a render call to update the light's shadow.
			 *
			 * @type {boolean}
			 * @default false
			 */ this.needsUpdate = false;
	        this._frustum = new Frustum();
	        this._frameExtents = new Vector2(1, 1);
	        this._viewportCount = 1;
	        this._viewports = [
	            new Vector4(0, 0, 1, 1)
	        ];
	    }
	}
	/**
	 * Represents the shadow configuration of directional lights.
	 *
	 * @augments LightShadow
	 */ class SpotLightShadow extends LightShadow {
	    updateMatrices(light) {
	        const camera = this.camera;
	        const fov = RAD2DEG * 2 * light.angle * this.focus;
	        const aspect = this.mapSize.width / this.mapSize.height;
	        const far = light.distance || camera.far;
	        if (fov !== camera.fov || aspect !== camera.aspect || far !== camera.far) {
	            camera.fov = fov;
	            camera.aspect = aspect;
	            camera.far = far;
	            camera.updateProjectionMatrix();
	        }
	        super.updateMatrices(light);
	    }
	    copy(source) {
	        super.copy(source);
	        this.focus = source.focus;
	        return this;
	    }
	    /**
		 * Constructs a new spot light shadow.
		 */ constructor(){
	        super(new PerspectiveCamera(50, 1, 0.5, 500));
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isSpotLightShadow = true;
	        /**
			 * Used to focus the shadow camera. The camera's field of view is set as a
			 * percentage of the spotlight's field-of-view. Range is `[0, 1]`.
			 *
			 * @type {number}
			 * @default 1
			 */ this.focus = 1;
	    }
	}
	/**
	 * This light gets emitted from a single point in one direction, along a cone
	 * that increases in size the further from the light it gets.
	 *
	 * This light can cast shadows - see the {@link SpotLightShadow} for details.
	 *
	 * ```js
	 * // white spotlight shining from the side, modulated by a texture
	 * const spotLight = new THREE.SpotLight( 0xffffff );
	 * spotLight.position.set( 100, 1000, 100 );
	 * spotLight.map = new THREE.TextureLoader().load( url );
	 *
	 * spotLight.castShadow = true;
	 * spotLight.shadow.mapSize.width = 1024;
	 * spotLight.shadow.mapSize.height = 1024;
	 * spotLight.shadow.camera.near = 500;
	 * spotLight.shadow.camera.far = 4000;
	 * spotLight.shadow.camera.fov = 30;s
	 * ```
	 *
	 * @augments Light
	 */ class SpotLight extends Light {
	    /**
		 * The light's power. Power is the luminous power of the light measured in lumens (lm).
		 *  Changing the power will also change the light's intensity.
		 *
		 * @type {number}
		 */ get power() {
	        // compute the light's luminous power (in lumens) from its intensity (in candela)
	        // by convention for a spotlight, luminous power (lm) = π * luminous intensity (cd)
	        return this.intensity * Math.PI;
	    }
	    set power(power) {
	        // set the light's intensity (in candela) from the desired luminous power (in lumens)
	        this.intensity = power / Math.PI;
	    }
	    dispose() {
	        this.shadow.dispose();
	    }
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.distance = source.distance;
	        this.angle = source.angle;
	        this.penumbra = source.penumbra;
	        this.decay = source.decay;
	        this.target = source.target.clone();
	        this.shadow = source.shadow.clone();
	        return this;
	    }
	    /**
		 * Constructs a new spot light.
		 *
		 * @param {(number|Color|string)} [color=0xffffff] - The light's color.
		 * @param {number} [intensity=1] - The light's strength/intensity measured in candela (cd).
		 * @param {number} [distance=0] - Maximum range of the light. `0` means no limit.
		 * @param {number} [angle=Math.PI/3] - Maximum angle of light dispersion from its direction whose upper bound is `Math.PI/2`.
		 * @param {number} [penumbra=0] - Percent of the spotlight cone that is attenuated due to penumbra. Value range is `[0,1]`.
		 * @param {number} [decay=2] - The amount the light dims along the distance of the light.
		 */ constructor(color, intensity, distance = 0, angle = Math.PI / 3, penumbra = 0, decay = 2){
	        super(color, intensity);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isSpotLight = true;
	        this.type = 'SpotLight';
	        this.position.copy(Object3D.DEFAULT_UP);
	        this.updateMatrix();
	        /**
			 * The spot light points from its position to the
			 * target's position.
			 *
			 * For the target's position to be changed to anything other
			 * than the default, it must be added to the scene.
			 *
			 * It is also possible to set the target to be another 3D object
			 * in the scene. The light will now track the target object.
			 *
			 * @type {Object3D}
			 */ this.target = new Object3D();
	        /**
			 * Maximum range of the light. `0` means no limit.
			 *
			 * @type {number}
			 * @default 0
			 */ this.distance = distance;
	        /**
			 * Maximum angle of light dispersion from its direction whose upper bound is `Math.PI/2`.
			 *
			 * @type {number}
			 * @default Math.PI/3
			 */ this.angle = angle;
	        /**
			 * Percent of the spotlight cone that is attenuated due to penumbra.
			 * Value range is `[0,1]`.
			 *
			 * @type {number}
			 * @default 0
			 */ this.penumbra = penumbra;
	        /**
			 * The amount the light dims along the distance of the light. In context of
			 * physically-correct rendering the default value should not be changed.
			 *
			 * @type {number}
			 * @default 2
			 */ this.decay = decay;
	        /**
			 * A texture used to modulate the color of the light. The spot light
			 * color is mixed with the RGB value of this texture, with a ratio
			 * corresponding to its alpha value. The cookie-like masking effect is
			 * reproduced using pixel values (0, 0, 0, 1-cookie_value).
			 *
			 * *Warning*: This property is disabled if {@link Object3D#castShadow} is set to `false`.
			 *
			 * @type {?Texture}
			 * @default null
			 */ this.map = null;
	        /**
			 * This property holds the light's shadow configuration.
			 *
			 * @type {SpotLightShadow}
			 */ this.shadow = new SpotLightShadow();
	    }
	}
	const _projScreenMatrix = /*@__PURE__*/ new Matrix4();
	const _lightPositionWorld = /*@__PURE__*/ new Vector3();
	const _lookTarget = /*@__PURE__*/ new Vector3();
	/**
	 * Represents the shadow configuration of point lights.
	 *
	 * @augments LightShadow
	 */ class PointLightShadow extends LightShadow {
	    /**
		 * Update the matrices for the camera and shadow, used internally by the renderer.
		 *
		 * @param {Light} light - The light for which the shadow is being rendered.
		 * @param {number} [viewportIndex=0] - The viewport index.
		 */ updateMatrices(light, viewportIndex = 0) {
	        const camera = this.camera;
	        const shadowMatrix = this.matrix;
	        const far = light.distance || camera.far;
	        if (far !== camera.far) {
	            camera.far = far;
	            camera.updateProjectionMatrix();
	        }
	        _lightPositionWorld.setFromMatrixPosition(light.matrixWorld);
	        camera.position.copy(_lightPositionWorld);
	        _lookTarget.copy(camera.position);
	        _lookTarget.add(this._cubeDirections[viewportIndex]);
	        camera.up.copy(this._cubeUps[viewportIndex]);
	        camera.lookAt(_lookTarget);
	        camera.updateMatrixWorld();
	        shadowMatrix.makeTranslation(-_lightPositionWorld.x, -_lightPositionWorld.y, -_lightPositionWorld.z);
	        _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
	        this._frustum.setFromProjectionMatrix(_projScreenMatrix);
	    }
	    /**
		 * Constructs a new point light shadow.
		 */ constructor(){
	        super(new PerspectiveCamera(90, 1, 0.5, 500));
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isPointLightShadow = true;
	        this._frameExtents = new Vector2(4, 2);
	        this._viewportCount = 6;
	        this._viewports = [
	            // These viewports map a cube-map onto a 2D texture with the
	            // following orientation:
	            //
	            //  xzXZ
	            //   y Y
	            //
	            // X - Positive x direction
	            // x - Negative x direction
	            // Y - Positive y direction
	            // y - Negative y direction
	            // Z - Positive z direction
	            // z - Negative z direction
	            // positive X
	            new Vector4(2, 1, 1, 1),
	            // negative X
	            new Vector4(0, 1, 1, 1),
	            // positive Z
	            new Vector4(3, 1, 1, 1),
	            // negative Z
	            new Vector4(1, 1, 1, 1),
	            // positive Y
	            new Vector4(3, 0, 1, 1),
	            // negative Y
	            new Vector4(1, 0, 1, 1)
	        ];
	        this._cubeDirections = [
	            new Vector3(1, 0, 0),
	            new Vector3(-1, 0, 0),
	            new Vector3(0, 0, 1),
	            new Vector3(0, 0, -1),
	            new Vector3(0, 1, 0),
	            new Vector3(0, -1, 0)
	        ];
	        this._cubeUps = [
	            new Vector3(0, 1, 0),
	            new Vector3(0, 1, 0),
	            new Vector3(0, 1, 0),
	            new Vector3(0, 1, 0),
	            new Vector3(0, 0, 1),
	            new Vector3(0, 0, -1)
	        ];
	    }
	}
	/**
	 * A light that gets emitted from a single point in all directions. A common
	 * use case for this is to replicate the light emitted from a bare
	 * lightbulb.
	 *
	 * This light can cast shadows - see the {@link PointLightShadow} for details.
	 *
	 * ```js
	 * const light = new THREE.PointLight( 0xff0000, 1, 100 );
	 * light.position.set( 50, 50, 50 );
	 * scene.add( light );
	 * ```
	 *
	 * @augments Light
	 */ class PointLight extends Light {
	    /**
		 * The light's power. Power is the luminous power of the light measured in lumens (lm).
		 * Changing the power will also change the light's intensity.
		 *
		 * @type {number}
		 */ get power() {
	        // compute the light's luminous power (in lumens) from its intensity (in candela)
	        // for an isotropic light source, luminous power (lm) = 4 π luminous intensity (cd)
	        return this.intensity * 4 * Math.PI;
	    }
	    set power(power) {
	        // set the light's intensity (in candela) from the desired luminous power (in lumens)
	        this.intensity = power / (4 * Math.PI);
	    }
	    dispose() {
	        this.shadow.dispose();
	    }
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.distance = source.distance;
	        this.decay = source.decay;
	        this.shadow = source.shadow.clone();
	        return this;
	    }
	    /**
		 * Constructs a new point light.
		 *
		 * @param {(number|Color|string)} [color=0xffffff] - The light's color.
		 * @param {number} [intensity=1] - The light's strength/intensity measured in candela (cd).
		 * @param {number} [distance=0] - Maximum range of the light. `0` means no limit.
		 * @param {number} [decay=2] - The amount the light dims along the distance of the light.
		 */ constructor(color, intensity, distance = 0, decay = 2){
	        super(color, intensity);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isPointLight = true;
	        this.type = 'PointLight';
	        /**
			 * When distance is zero, light will attenuate according to inverse-square
			 * law to infinite distance. When distance is non-zero, light will attenuate
			 * according to inverse-square law until near the distance cutoff, where it
			 * will then attenuate quickly and smoothly to 0. Inherently, cutoffs are not
			 * physically correct.
			 *
			 * @type {number}
			 * @default 0
			 */ this.distance = distance;
	        /**
			 * The amount the light dims along the distance of the light. In context of
			 * physically-correct rendering the default value should not be changed.
			 *
			 * @type {number}
			 * @default 2
			 */ this.decay = decay;
	        /**
			 * This property holds the light's shadow configuration.
			 *
			 * @type {PointLightShadow}
			 */ this.shadow = new PointLightShadow();
	    }
	}
	/**
	 * Camera that uses [orthographic projection]{@link https://en.wikipedia.org/wiki/Orthographic_projection}.
	 *
	 * In this projection mode, an object's size in the rendered image stays
	 * constant regardless of its distance from the camera. This can be useful
	 * for rendering 2D scenes and UI elements, amongst other things.
	 *
	 * ```js
	 * const camera = new THREE.OrthographicCamera( width / - 2, width / 2, height / 2, height / - 2, 1, 1000 );
	 * scene.add( camera );
	 * ```
	 *
	 * @augments Camera
	 */ class OrthographicCamera extends Camera {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.left = source.left;
	        this.right = source.right;
	        this.top = source.top;
	        this.bottom = source.bottom;
	        this.near = source.near;
	        this.far = source.far;
	        this.zoom = source.zoom;
	        this.view = source.view === null ? null : Object.assign({}, source.view);
	        return this;
	    }
	    /**
		 * Sets an offset in a larger frustum. This is useful for multi-window or
		 * multi-monitor/multi-machine setups.
		 *
		 * @param {number} fullWidth - The full width of multiview setup.
		 * @param {number} fullHeight - The full height of multiview setup.
		 * @param {number} x - The horizontal offset of the subcamera.
		 * @param {number} y - The vertical offset of the subcamera.
		 * @param {number} width - The width of subcamera.
		 * @param {number} height - The height of subcamera.
		 * @see {@link PerspectiveCamera#setViewOffset}
		 */ setViewOffset(fullWidth, fullHeight, x, y, width, height) {
	        if (this.view === null) {
	            this.view = {
	                enabled: true,
	                fullWidth: 1,
	                fullHeight: 1,
	                offsetX: 0,
	                offsetY: 0,
	                width: 1,
	                height: 1
	            };
	        }
	        this.view.enabled = true;
	        this.view.fullWidth = fullWidth;
	        this.view.fullHeight = fullHeight;
	        this.view.offsetX = x;
	        this.view.offsetY = y;
	        this.view.width = width;
	        this.view.height = height;
	        this.updateProjectionMatrix();
	    }
	    /**
		 * Removes the view offset from the projection matrix.
		 */ clearViewOffset() {
	        if (this.view !== null) {
	            this.view.enabled = false;
	        }
	        this.updateProjectionMatrix();
	    }
	    /**
		 * Updates the camera's projection matrix. Must be called after any change of
		 * camera properties.
		 */ updateProjectionMatrix() {
	        const dx = (this.right - this.left) / (2 * this.zoom);
	        const dy = (this.top - this.bottom) / (2 * this.zoom);
	        const cx = (this.right + this.left) / 2;
	        const cy = (this.top + this.bottom) / 2;
	        let left = cx - dx;
	        let right = cx + dx;
	        let top = cy + dy;
	        let bottom = cy - dy;
	        if (this.view !== null && this.view.enabled) {
	            const scaleW = (this.right - this.left) / this.view.fullWidth / this.zoom;
	            const scaleH = (this.top - this.bottom) / this.view.fullHeight / this.zoom;
	            left += scaleW * this.view.offsetX;
	            right = left + scaleW * this.view.width;
	            top -= scaleH * this.view.offsetY;
	            bottom = top - scaleH * this.view.height;
	        }
	        this.projectionMatrix.makeOrthographic(left, right, top, bottom, this.near, this.far, this.coordinateSystem);
	        this.projectionMatrixInverse.copy(this.projectionMatrix).invert();
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        data.object.zoom = this.zoom;
	        data.object.left = this.left;
	        data.object.right = this.right;
	        data.object.top = this.top;
	        data.object.bottom = this.bottom;
	        data.object.near = this.near;
	        data.object.far = this.far;
	        if (this.view !== null) data.object.view = Object.assign({}, this.view);
	        return data;
	    }
	    /**
		 * Constructs a new orthographic camera.
		 *
		 * @param {number} [left=-1] - The left plane of the camera's frustum.
		 * @param {number} [right=1] - The right plane of the camera's frustum.
		 * @param {number} [top=1] - The top plane of the camera's frustum.
		 * @param {number} [bottom=-1] - The bottom plane of the camera's frustum.
		 * @param {number} [near=0.1] - The camera's near plane.
		 * @param {number} [far=2000] - The camera's far plane.
		 */ constructor(left = -1, right = 1, top = 1, bottom = -1, near = 0.1, far = 2000){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isOrthographicCamera = true;
	        this.type = 'OrthographicCamera';
	        /**
			 * The zoom factor of the camera.
			 *
			 * @type {number}
			 * @default 1
			 */ this.zoom = 1;
	        /**
			 * Represents the frustum window specification. This property should not be edited
			 * directly but via {@link PerspectiveCamera#setViewOffset} and {@link PerspectiveCamera#clearViewOffset}.
			 *
			 * @type {?Object}
			 * @default null
			 */ this.view = null;
	        /**
			 * The left plane of the camera's frustum.
			 *
			 * @type {number}
			 * @default -1
			 */ this.left = left;
	        /**
			 * The right plane of the camera's frustum.
			 *
			 * @type {number}
			 * @default 1
			 */ this.right = right;
	        /**
			 * The top plane of the camera's frustum.
			 *
			 * @type {number}
			 * @default 1
			 */ this.top = top;
	        /**
			 * The bottom plane of the camera's frustum.
			 *
			 * @type {number}
			 * @default -1
			 */ this.bottom = bottom;
	        /**
			 * The camera's near plane. The valid range is greater than `0`
			 * and less than the current value of {@link OrthographicCamera#far}.
			 *
			 * Note that, unlike for the {@link PerspectiveCamera}, `0` is a
			 * valid value for an orthographic camera's near plane.
			 *
			 * @type {number}
			 * @default 0.1
			 */ this.near = near;
	        /**
			 * The camera's far plane. Must be greater than the
			 * current value of {@link OrthographicCamera#near}.
			 *
			 * @type {number}
			 * @default 2000
			 */ this.far = far;
	        this.updateProjectionMatrix();
	    }
	}
	/**
	 * Represents the shadow configuration of directional lights.
	 *
	 * @augments LightShadow
	 */ class DirectionalLightShadow extends LightShadow {
	    /**
		 * Constructs a new directional light shadow.
		 */ constructor(){
	        super(new OrthographicCamera(-5, 5, 5, -5, 0.5, 500));
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isDirectionalLightShadow = true;
	    }
	}
	/**
	 * A light that gets emitted in a specific direction. This light will behave
	 * as though it is infinitely far away and the rays produced from it are all
	 * parallel. The common use case for this is to simulate daylight; the sun is
	 * far enough away that its position can be considered to be infinite, and
	 * all light rays coming from it are parallel.
	 *
	 * A common point of confusion for directional lights is that setting the
	 * rotation has no effect. This is because three.js's DirectionalLight is the
	 * equivalent to what is often called a 'Target Direct Light' in other
	 * applications.
	 *
	 * This means that its direction is calculated as pointing from the light's
	 * {@link Object3D#position} to the {@link DirectionalLight#target} position
	 * (as opposed to a 'Free Direct Light' that just has a rotation
	 * component).
	 *
	 * This light can cast shadows - see the {@link DirectionalLightShadow} for details.
	 *
	 * ```js
	 * // White directional light at half intensity shining from the top.
	 * const directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 );
	 * scene.add( directionalLight );
	 * ```
	 *
	 * @augments Light
	 */ class DirectionalLight extends Light {
	    dispose() {
	        this.shadow.dispose();
	    }
	    copy(source) {
	        super.copy(source);
	        this.target = source.target.clone();
	        this.shadow = source.shadow.clone();
	        return this;
	    }
	    /**
		 * Constructs a new directional light.
		 *
		 * @param {(number|Color|string)} [color=0xffffff] - The light's color.
		 * @param {number} [intensity=1] - The light's strength/intensity.
		 */ constructor(color, intensity){
	        super(color, intensity);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isDirectionalLight = true;
	        this.type = 'DirectionalLight';
	        this.position.copy(Object3D.DEFAULT_UP);
	        this.updateMatrix();
	        /**
			 * The directional light points from its position to the
			 * target's position.
			 *
			 * For the target's position to be changed to anything other
			 * than the default, it must be added to the scene.
			 *
			 * It is also possible to set the target to be another 3D object
			 * in the scene. The light will now track the target object.
			 *
			 * @type {Object3D}
			 */ this.target = new Object3D();
	        /**
			 * This property holds the light's shadow configuration.
			 *
			 * @type {DirectionalLightShadow}
			 */ this.shadow = new DirectionalLightShadow();
	    }
	}
	/**
	 * Represents a third-order spherical harmonics (SH). Light probes use this class
	 * to encode lighting information.
	 *
	 * - Primary reference: {@link https://graphics.stanford.edu/papers/envmap/envmap.pdf}
	 * - Secondary reference: {@link https://www.ppsloan.org/publications/StupidSH36.pdf}
	 */ class SphericalHarmonics3 {
	    /**
		 * Sets the given SH coefficients to this instance by copying
		 * the values.
		 *
		 * @param {Array<Vector3>} coefficients - The SH coefficients.
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ set(coefficients) {
	        for(let i = 0; i < 9; i++){
	            this.coefficients[i].copy(coefficients[i]);
	        }
	        return this;
	    }
	    /**
		 * Sets all SH coefficients to `0`.
		 *
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ zero() {
	        for(let i = 0; i < 9; i++){
	            this.coefficients[i].set(0, 0, 0);
	        }
	        return this;
	    }
	    /**
		 * Returns the radiance in the direction of the given normal.
		 *
		 * @param {Vector3} normal - The normal vector (assumed to be unit length)
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The radiance.
		 */ getAt(normal, target) {
	        // normal is assumed to be unit length
	        const x = normal.x, y = normal.y, z = normal.z;
	        const coeff = this.coefficients;
	        // band 0
	        target.copy(coeff[0]).multiplyScalar(0.282095);
	        // band 1
	        target.addScaledVector(coeff[1], 0.488603 * y);
	        target.addScaledVector(coeff[2], 0.488603 * z);
	        target.addScaledVector(coeff[3], 0.488603 * x);
	        // band 2
	        target.addScaledVector(coeff[4], 1.092548 * (x * y));
	        target.addScaledVector(coeff[5], 1.092548 * (y * z));
	        target.addScaledVector(coeff[6], 0.315392 * (3.0 * z * z - 1.0));
	        target.addScaledVector(coeff[7], 1.092548 * (x * z));
	        target.addScaledVector(coeff[8], 0.546274 * (x * x - y * y));
	        return target;
	    }
	    /**
		 * Returns the irradiance (radiance convolved with cosine lobe) in the
		 * direction of the given normal.
		 *
		 * @param {Vector3} normal - The normal vector (assumed to be unit length)
		 * @param {Vector3} target - The target vector that is used to store the method's result.
		 * @return {Vector3} The irradiance.
		 */ getIrradianceAt(normal, target) {
	        // normal is assumed to be unit length
	        const x = normal.x, y = normal.y, z = normal.z;
	        const coeff = this.coefficients;
	        // band 0
	        target.copy(coeff[0]).multiplyScalar(0.886227); // π * 0.282095
	        // band 1
	        target.addScaledVector(coeff[1], 2.0 * 0.511664 * y); // ( 2 * π / 3 ) * 0.488603
	        target.addScaledVector(coeff[2], 2.0 * 0.511664 * z);
	        target.addScaledVector(coeff[3], 2.0 * 0.511664 * x);
	        // band 2
	        target.addScaledVector(coeff[4], 2.0 * 0.429043 * x * y); // ( π / 4 ) * 1.092548
	        target.addScaledVector(coeff[5], 2.0 * 0.429043 * y * z);
	        target.addScaledVector(coeff[6], 0.743125 * z * z - 0.247708); // ( π / 4 ) * 0.315392 * 3
	        target.addScaledVector(coeff[7], 2.0 * 0.429043 * x * z);
	        target.addScaledVector(coeff[8], 0.429043 * (x * x - y * y)); // ( π / 4 ) * 0.546274
	        return target;
	    }
	    /**
		 * Adds the given SH to this instance.
		 *
		 * @param {SphericalHarmonics3} sh - The SH to add.
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ add(sh) {
	        for(let i = 0; i < 9; i++){
	            this.coefficients[i].add(sh.coefficients[i]);
	        }
	        return this;
	    }
	    /**
		 * A convenience method for performing {@link SphericalHarmonics3#add} and
		 * {@link SphericalHarmonics3#scale} at once.
		 *
		 * @param {SphericalHarmonics3} sh - The SH to add.
		 * @param {number} s - The scale factor.
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ addScaledSH(sh, s) {
	        for(let i = 0; i < 9; i++){
	            this.coefficients[i].addScaledVector(sh.coefficients[i], s);
	        }
	        return this;
	    }
	    /**
		 * Scales this SH by the given scale factor.
		 *
		 * @param {number} s - The scale factor.
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ scale(s) {
	        for(let i = 0; i < 9; i++){
	            this.coefficients[i].multiplyScalar(s);
	        }
	        return this;
	    }
	    /**
		 * Linear interpolates between the given SH and this instance by the given
		 * alpha factor.
		 *
		 * @param {SphericalHarmonics3} sh - The SH to interpolate with.
		 * @param {number} alpha - The alpha factor.
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ lerp(sh, alpha) {
	        for(let i = 0; i < 9; i++){
	            this.coefficients[i].lerp(sh.coefficients[i], alpha);
	        }
	        return this;
	    }
	    /**
		 * Returns `true` if this spherical harmonics is equal with the given one.
		 *
		 * @param {SphericalHarmonics3} sh - The spherical harmonics to test for equality.
		 * @return {boolean} Whether this spherical harmonics is equal with the given one.
		 */ equals(sh) {
	        for(let i = 0; i < 9; i++){
	            if (!this.coefficients[i].equals(sh.coefficients[i])) {
	                return false;
	            }
	        }
	        return true;
	    }
	    /**
		 * Copies the values of the given spherical harmonics to this instance.
		 *
		 * @param {SphericalHarmonics3} sh - The spherical harmonics to copy.
		 * @return {SphericalHarmonics3} A reference to this spherical harmonics.
		 */ copy(sh) {
	        return this.set(sh.coefficients);
	    }
	    /**
		 * Returns a new spherical harmonics with copied values from this instance.
		 *
		 * @return {SphericalHarmonics3} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Sets the SH coefficients of this instance from the given array.
		 *
		 * @param {Array<number>} array - An array holding the SH coefficients.
		 * @param {number} [offset=0] - The array offset where to start copying.
		 * @return {SphericalHarmonics3} A clone of this instance.
		 */ fromArray(array, offset = 0) {
	        const coefficients = this.coefficients;
	        for(let i = 0; i < 9; i++){
	            coefficients[i].fromArray(array, offset + i * 3);
	        }
	        return this;
	    }
	    /**
		 * Returns an array with the SH coefficients, or copies them into the provided
		 * array. The coefficients are represented as numbers.
		 *
		 * @param {Array<number>} [array=[]] - The target array.
		 * @param {number} [offset=0] - The array offset where to start copying.
		 * @return {Array<number>} An array with flat SH coefficients.
		 */ toArray(array = [], offset = 0) {
	        const coefficients = this.coefficients;
	        for(let i = 0; i < 9; i++){
	            coefficients[i].toArray(array, offset + i * 3);
	        }
	        return array;
	    }
	    /**
		 * Computes the SH basis for the given normal vector.
		 *
		 * @param {Vector3} normal - The normal.
		 * @param {Array<number>} shBasis - The target array holding the SH basis.
		 */ static getBasisAt(normal, shBasis) {
	        // normal is assumed to be unit length
	        const x = normal.x, y = normal.y, z = normal.z;
	        // band 0
	        shBasis[0] = 0.282095;
	        // band 1
	        shBasis[1] = 0.488603 * y;
	        shBasis[2] = 0.488603 * z;
	        shBasis[3] = 0.488603 * x;
	        // band 2
	        shBasis[4] = 1.092548 * x * y;
	        shBasis[5] = 1.092548 * y * z;
	        shBasis[6] = 0.315392 * (3 * z * z - 1);
	        shBasis[7] = 1.092548 * x * z;
	        shBasis[8] = 0.546274 * (x * x - y * y);
	    }
	    /**
		 * Constructs a new spherical harmonics.
		 */ constructor(){
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isSphericalHarmonics3 = true;
	        /**
			 * An array holding the (9) SH coefficients.
			 *
			 * @type {Array<Vector3>}
			 */ this.coefficients = [];
	        for(let i = 0; i < 9; i++){
	            this.coefficients.push(new Vector3());
	        }
	    }
	}
	/**
	 * Light probes are an alternative way of adding light to a 3D scene. Unlike
	 * classical light sources (e.g. directional, point or spot lights), light
	 * probes do not emit light. Instead they store information about light
	 * passing through 3D space. During rendering, the light that hits a 3D
	 * object is approximated by using the data from the light probe.
	 *
	 * Light probes are usually created from (radiance) environment maps. The
	 * class {@link LightProbeGenerator} can be used to create light probes from
	 * cube textures or render targets. However, light estimation data could also
	 * be provided in other forms e.g. by WebXR. This enables the rendering of
	 * augmented reality content that reacts to real world lighting.
	 *
	 * The current probe implementation in three.js supports so-called diffuse
	 * light probes. This type of light probe is functionally equivalent to an
	 * irradiance environment map.
	 *
	 * @augments Light
	 */ class LightProbe extends Light {
	    copy(source) {
	        super.copy(source);
	        this.sh.copy(source.sh);
	        return this;
	    }
	    /**
		 * Deserializes the light prove from the given JSON.
		 *
		 * @param {Object} json - The JSON holding the serialized light probe.
		 * @return {LightProbe} A reference to this light probe.
		 */ fromJSON(json) {
	        this.intensity = json.intensity; // TODO: Move this bit to Light.fromJSON();
	        this.sh.fromArray(json.sh);
	        return this;
	    }
	    toJSON(meta) {
	        const data = super.toJSON(meta);
	        data.object.sh = this.sh.toArray();
	        return data;
	    }
	    /**
		 * Constructs a new light probe.
		 *
		 * @param {SphericalHarmonics3} sh - The spherical harmonics which represents encoded lighting information.
		 * @param {number} [intensity=1] - The light's strength/intensity.
		 */ constructor(sh = new SphericalHarmonics3(), intensity = 1){
	        super(undefined, intensity);
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isLightProbe = true;
	        /**
			 * A light probe uses spherical harmonics to encode lighting information.
			 *
			 * @type {SphericalHarmonics3}
			 */ this.sh = sh;
	    }
	}
	class LoaderUtils {
	    static decodeText(array) {
	        console.warn('THREE.LoaderUtils: decodeText() has been deprecated with r165 and will be removed with r175. Use TextDecoder instead.');
	        if (typeof TextDecoder !== 'undefined') {
	            return new TextDecoder().decode(array);
	        }
	        // Avoid the String.fromCharCode.apply(null, array) shortcut, which
	        // throws a "maximum call stack size exceeded" error for large arrays.
	        let s = '';
	        for(let i = 0, il = array.length; i < il; i++){
	            // Implicitly assumes little-endian.
	            s += String.fromCharCode(array[i]);
	        }
	        try {
	            // merges multi-byte utf-8 characters.
	            return decodeURIComponent(escape(s));
	        } catch (e) {
	            return s;
	        }
	    }
	    static extractUrlBase(url) {
	        const index = url.lastIndexOf('/');
	        if (index === -1) return './';
	        return url.slice(0, index + 1);
	    }
	    static resolveURL(url, path) {
	        // Invalid URL
	        if (typeof url !== 'string' || url === '') return '';
	        // Host Relative URL
	        if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
	            path = path.replace(/(^https?:\/\/[^\/]+).*/i, '$1');
	        }
	        // Absolute URL http://,https://,//
	        if (/^(https?:)?\/\//i.test(url)) return url;
	        // Data URI
	        if (/^data:.*,.*$/i.test(url)) return url;
	        // Blob URL
	        if (/^blob:.*$/i.test(url)) return url;
	        // Relative URL
	        return path + url;
	    }
	}
	class ImageBitmapLoader extends Loader {
	    setOptions(options) {
	        this.options = options;
	        return this;
	    }
	    load(url, onLoad, onProgress, onError) {
	        if (url === undefined) url = '';
	        if (this.path !== undefined) url = this.path + url;
	        url = this.manager.resolveURL(url);
	        const scope = this;
	        const cached = Cache.get(url);
	        if (cached !== undefined) {
	            scope.manager.itemStart(url);
	            // If cached is a promise, wait for it to resolve
	            if (cached.then) {
	                cached.then((imageBitmap)=>{
	                    if (onLoad) onLoad(imageBitmap);
	                    scope.manager.itemEnd(url);
	                }).catch((e)=>{
	                    if (onError) onError(e);
	                });
	                return;
	            }
	            // If cached is not a promise (i.e., it's already an imageBitmap)
	            setTimeout(function() {
	                if (onLoad) onLoad(cached);
	                scope.manager.itemEnd(url);
	            }, 0);
	            return cached;
	        }
	        const fetchOptions = {};
	        fetchOptions.credentials = this.crossOrigin === 'anonymous' ? 'same-origin' : 'include';
	        fetchOptions.headers = this.requestHeader;
	        const promise = fetch(url, fetchOptions).then(function(res) {
	            return res.blob();
	        }).then(function(blob) {
	            return createImageBitmap(blob, Object.assign(scope.options, {
	                colorSpaceConversion: 'none'
	            }));
	        }).then(function(imageBitmap) {
	            Cache.add(url, imageBitmap);
	            if (onLoad) onLoad(imageBitmap);
	            scope.manager.itemEnd(url);
	            return imageBitmap;
	        }).catch(function(e) {
	            if (onError) onError(e);
	            Cache.remove(url);
	            scope.manager.itemError(url);
	            scope.manager.itemEnd(url);
	        });
	        Cache.add(url, promise);
	        scope.manager.itemStart(url);
	    }
	    constructor(manager){
	        super(manager);
	        this.isImageBitmapLoader = true;
	        if (typeof createImageBitmap === 'undefined') {
	            console.warn('THREE.ImageBitmapLoader: createImageBitmap() not supported.');
	        }
	        if (typeof fetch === 'undefined') {
	            console.warn('THREE.ImageBitmapLoader: fetch() not supported.');
	        }
	        this.options = {
	            premultiplyAlpha: 'none'
	        };
	    }
	}
	/**
	 * This type of camera can be used in order to efficiently render a scene with a
	 * predefined set of cameras. This is an important performance aspect for
	 * rendering VR scenes.
	 *
	 * An instance of `ArrayCamera` always has an array of sub cameras. It's mandatory
	 * to define for each sub camera the `viewport` property which determines the
	 * part of the viewport that is rendered with this camera.
	 *
	 * @augments PerspectiveCamera
	 */ class ArrayCamera extends PerspectiveCamera {
	    /**
		 * Constructs a new array camera.
		 *
		 * @param {Array<PerspectiveCamera>} [array=[]] - An array of perspective sub cameras.
		 */ constructor(array = []){
	        super();
	        /**
			 * This flag can be used for type testing.
			 *
			 * @type {boolean}
			 * @readonly
			 * @default true
			 */ this.isArrayCamera = true;
	        /**
			 * An array of perspective sub cameras.
			 *
			 * @type {Array<PerspectiveCamera>}
			 */ this.cameras = array;
	        this.index = 0;
	    }
	}
	class PropertyMixer {
	    // accumulate data in the 'incoming' region into 'accu<i>'
	    accumulate(accuIndex, weight) {
	        // note: happily accumulating nothing when weight = 0, the caller knows
	        // the weight and shouldn't have made the call in the first place
	        const buffer = this.buffer, stride = this.valueSize, offset = accuIndex * stride + stride;
	        let currentWeight = this.cumulativeWeight;
	        if (currentWeight === 0) {
	            // accuN := incoming * weight
	            for(let i = 0; i !== stride; ++i){
	                buffer[offset + i] = buffer[i];
	            }
	            currentWeight = weight;
	        } else {
	            // accuN := accuN + incoming * weight
	            currentWeight += weight;
	            const mix = weight / currentWeight;
	            this._mixBufferRegion(buffer, offset, 0, mix, stride);
	        }
	        this.cumulativeWeight = currentWeight;
	    }
	    // accumulate data in the 'incoming' region into 'add'
	    accumulateAdditive(weight) {
	        const buffer = this.buffer, stride = this.valueSize, offset = stride * this._addIndex;
	        if (this.cumulativeWeightAdditive === 0) {
	            // add = identity
	            this._setIdentity();
	        }
	        // add := add + incoming * weight
	        this._mixBufferRegionAdditive(buffer, offset, 0, weight, stride);
	        this.cumulativeWeightAdditive += weight;
	    }
	    // apply the state of 'accu<i>' to the binding when accus differ
	    apply(accuIndex) {
	        const stride = this.valueSize, buffer = this.buffer, offset = accuIndex * stride + stride, weight = this.cumulativeWeight, weightAdditive = this.cumulativeWeightAdditive, binding = this.binding;
	        this.cumulativeWeight = 0;
	        this.cumulativeWeightAdditive = 0;
	        if (weight < 1) {
	            // accuN := accuN + original * ( 1 - cumulativeWeight )
	            const originalValueOffset = stride * this._origIndex;
	            this._mixBufferRegion(buffer, offset, originalValueOffset, 1 - weight, stride);
	        }
	        if (weightAdditive > 0) {
	            // accuN := accuN + additive accuN
	            this._mixBufferRegionAdditive(buffer, offset, this._addIndex * stride, 1, stride);
	        }
	        for(let i = stride, e = stride + stride; i !== e; ++i){
	            if (buffer[i] !== buffer[i + stride]) {
	                // value has changed -> update scene graph
	                binding.setValue(buffer, offset);
	                break;
	            }
	        }
	    }
	    // remember the state of the bound property and copy it to both accus
	    saveOriginalState() {
	        const binding = this.binding;
	        const buffer = this.buffer, stride = this.valueSize, originalValueOffset = stride * this._origIndex;
	        binding.getValue(buffer, originalValueOffset);
	        // accu[0..1] := orig -- initially detect changes against the original
	        for(let i = stride, e = originalValueOffset; i !== e; ++i){
	            buffer[i] = buffer[originalValueOffset + i % stride];
	        }
	        // Add to identity for additive
	        this._setIdentity();
	        this.cumulativeWeight = 0;
	        this.cumulativeWeightAdditive = 0;
	    }
	    // apply the state previously taken via 'saveOriginalState' to the binding
	    restoreOriginalState() {
	        const originalValueOffset = this.valueSize * 3;
	        this.binding.setValue(this.buffer, originalValueOffset);
	    }
	    _setAdditiveIdentityNumeric() {
	        const startIndex = this._addIndex * this.valueSize;
	        const endIndex = startIndex + this.valueSize;
	        for(let i = startIndex; i < endIndex; i++){
	            this.buffer[i] = 0;
	        }
	    }
	    _setAdditiveIdentityQuaternion() {
	        this._setAdditiveIdentityNumeric();
	        this.buffer[this._addIndex * this.valueSize + 3] = 1;
	    }
	    _setAdditiveIdentityOther() {
	        const startIndex = this._origIndex * this.valueSize;
	        const targetIndex = this._addIndex * this.valueSize;
	        for(let i = 0; i < this.valueSize; i++){
	            this.buffer[targetIndex + i] = this.buffer[startIndex + i];
	        }
	    }
	    // mix functions
	    _select(buffer, dstOffset, srcOffset, t, stride) {
	        if (t >= 0.5) {
	            for(let i = 0; i !== stride; ++i){
	                buffer[dstOffset + i] = buffer[srcOffset + i];
	            }
	        }
	    }
	    _slerp(buffer, dstOffset, srcOffset, t) {
	        Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t);
	    }
	    _slerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
	        const workOffset = this._workIndex * stride;
	        // Store result in intermediate buffer offset
	        Quaternion.multiplyQuaternionsFlat(buffer, workOffset, buffer, dstOffset, buffer, srcOffset);
	        // Slerp to the intermediate result
	        Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t);
	    }
	    _lerp(buffer, dstOffset, srcOffset, t, stride) {
	        const s = 1 - t;
	        for(let i = 0; i !== stride; ++i){
	            const j = dstOffset + i;
	            buffer[j] = buffer[j] * s + buffer[srcOffset + i] * t;
	        }
	    }
	    _lerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
	        for(let i = 0; i !== stride; ++i){
	            const j = dstOffset + i;
	            buffer[j] = buffer[j] + buffer[srcOffset + i] * t;
	        }
	    }
	    constructor(binding, typeName, valueSize){
	        this.binding = binding;
	        this.valueSize = valueSize;
	        let mixFunction, mixFunctionAdditive, setIdentity;
	        // buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ]
	        //
	        // interpolators can use .buffer as their .result
	        // the data then goes to 'incoming'
	        //
	        // 'accu0' and 'accu1' are used frame-interleaved for
	        // the cumulative result and are compared to detect
	        // changes
	        //
	        // 'orig' stores the original state of the property
	        //
	        // 'add' is used for additive cumulative results
	        //
	        // 'work' is optional and is only present for quaternion types. It is used
	        // to store intermediate quaternion multiplication results
	        switch(typeName){
	            case 'quaternion':
	                mixFunction = this._slerp;
	                mixFunctionAdditive = this._slerpAdditive;
	                setIdentity = this._setAdditiveIdentityQuaternion;
	                this.buffer = new Float64Array(valueSize * 6);
	                this._workIndex = 5;
	                break;
	            case 'string':
	            case 'bool':
	                mixFunction = this._select;
	                // Use the regular mix function and for additive on these types,
	                // additive is not relevant for non-numeric types
	                mixFunctionAdditive = this._select;
	                setIdentity = this._setAdditiveIdentityOther;
	                this.buffer = new Array(valueSize * 5);
	                break;
	            default:
	                mixFunction = this._lerp;
	                mixFunctionAdditive = this._lerpAdditive;
	                setIdentity = this._setAdditiveIdentityNumeric;
	                this.buffer = new Float64Array(valueSize * 5);
	        }
	        this._mixBufferRegion = mixFunction;
	        this._mixBufferRegionAdditive = mixFunctionAdditive;
	        this._setIdentity = setIdentity;
	        this._origIndex = 3;
	        this._addIndex = 4;
	        this.cumulativeWeight = 0;
	        this.cumulativeWeightAdditive = 0;
	        this.useCount = 0;
	        this.referenceCount = 0;
	    }
	}
	// Characters [].:/ are reserved for track binding syntax.
	const _RESERVED_CHARS_RE = '\\[\\]\\.:\\/';
	const _reservedRe = new RegExp('[' + _RESERVED_CHARS_RE + ']', 'g');
	// Attempts to allow node names from any language. ES5's `\w` regexp matches
	// only latin characters, and the unicode \p{L} is not yet supported. So
	// instead, we exclude reserved characters and match everything else.
	const _wordChar = '[^' + _RESERVED_CHARS_RE + ']';
	const _wordCharOrDot = '[^' + _RESERVED_CHARS_RE.replace('\\.', '') + ']';
	// Parent directories, delimited by '/' or ':'. Currently unused, but must
	// be matched to parse the rest of the track name.
	const _directoryRe = /*@__PURE__*/ /((?:WC+[\/:])*)/.source.replace('WC', _wordChar);
	// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.
	const _nodeRe = /*@__PURE__*/ /(WCOD+)?/.source.replace('WCOD', _wordCharOrDot);
	// Object on target node, and accessor. May not contain reserved
	// characters. Accessor may contain any character except closing bracket.
	const _objectRe = /*@__PURE__*/ /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace('WC', _wordChar);
	// Property and accessor. May not contain reserved characters. Accessor may
	// contain any non-bracket characters.
	const _propertyRe = /*@__PURE__*/ /\.(WC+)(?:\[(.+)\])?/.source.replace('WC', _wordChar);
	const _trackRe = new RegExp('' + '^' + _directoryRe + _nodeRe + _objectRe + _propertyRe + '$');
	const _supportedObjectNames = [
	    'material',
	    'materials',
	    'bones',
	    'map'
	];
	class Composite {
	    getValue(array, offset) {
	        this.bind(); // bind all binding
	        const firstValidIndex = this._targetGroup.nCachedObjects_, binding = this._bindings[firstValidIndex];
	        // and only call .getValue on the first
	        if (binding !== undefined) binding.getValue(array, offset);
	    }
	    setValue(array, offset) {
	        const bindings = this._bindings;
	        for(let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i){
	            bindings[i].setValue(array, offset);
	        }
	    }
	    bind() {
	        const bindings = this._bindings;
	        for(let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i){
	            bindings[i].bind();
	        }
	    }
	    unbind() {
	        const bindings = this._bindings;
	        for(let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i){
	            bindings[i].unbind();
	        }
	    }
	    constructor(targetGroup, path, optionalParsedPath){
	        const parsedPath = optionalParsedPath || PropertyBinding.parseTrackName(path);
	        this._targetGroup = targetGroup;
	        this._bindings = targetGroup.subscribe_(path, parsedPath);
	    }
	}
	// Note: This class uses a State pattern on a per-method basis:
	// 'bind' sets 'this.getValue' / 'setValue' and shadows the
	// prototype version of these methods with one that represents
	// the bound state. When the property is not found, the methods
	// become no-ops.
	class PropertyBinding {
	    static create(root, path, parsedPath) {
	        if (!(root && root.isAnimationObjectGroup)) {
	            return new PropertyBinding(root, path, parsedPath);
	        } else {
	            return new PropertyBinding.Composite(root, path, parsedPath);
	        }
	    }
	    /**
		 * Replaces spaces with underscores and removes unsupported characters from
		 * node names, to ensure compatibility with parseTrackName().
		 *
		 * @param {string} name Node name to be sanitized.
		 * @return {string}
		 */ static sanitizeNodeName(name) {
	        return name.replace(/\s/g, '_').replace(_reservedRe, '');
	    }
	    static parseTrackName(trackName) {
	        const matches = _trackRe.exec(trackName);
	        if (matches === null) {
	            throw new Error('PropertyBinding: Cannot parse trackName: ' + trackName);
	        }
	        const results = {
	            // directoryName: matches[ 1 ], // (tschw) currently unused
	            nodeName: matches[2],
	            objectName: matches[3],
	            objectIndex: matches[4],
	            propertyName: matches[5],
	            propertyIndex: matches[6]
	        };
	        const lastDot = results.nodeName && results.nodeName.lastIndexOf('.');
	        if (lastDot !== undefined && lastDot !== -1) {
	            const objectName = results.nodeName.substring(lastDot + 1);
	            // Object names must be checked against an allowlist. Otherwise, there
	            // is no way to parse 'foo.bar.baz': 'baz' must be a property, but
	            // 'bar' could be the objectName, or part of a nodeName (which can
	            // include '.' characters).
	            if (_supportedObjectNames.indexOf(objectName) !== -1) {
	                results.nodeName = results.nodeName.substring(0, lastDot);
	                results.objectName = objectName;
	            }
	        }
	        if (results.propertyName === null || results.propertyName.length === 0) {
	            throw new Error('PropertyBinding: can not parse propertyName from trackName: ' + trackName);
	        }
	        return results;
	    }
	    static findNode(root, nodeName) {
	        if (nodeName === undefined || nodeName === '' || nodeName === '.' || nodeName === -1 || nodeName === root.name || nodeName === root.uuid) {
	            return root;
	        }
	        // search into skeleton bones.
	        if (root.skeleton) {
	            const bone = root.skeleton.getBoneByName(nodeName);
	            if (bone !== undefined) {
	                return bone;
	            }
	        }
	        // search into node subtree.
	        if (root.children) {
	            const searchNodeSubtree = function(children) {
	                for(let i = 0; i < children.length; i++){
	                    const childNode = children[i];
	                    if (childNode.name === nodeName || childNode.uuid === nodeName) {
	                        return childNode;
	                    }
	                    const result = searchNodeSubtree(childNode.children);
	                    if (result) return result;
	                }
	                return null;
	            };
	            const subTreeNode = searchNodeSubtree(root.children);
	            if (subTreeNode) {
	                return subTreeNode;
	            }
	        }
	        return null;
	    }
	    // these are used to "bind" a nonexistent property
	    _getValue_unavailable() {}
	    _setValue_unavailable() {}
	    // Getters
	    _getValue_direct(buffer, offset) {
	        buffer[offset] = this.targetObject[this.propertyName];
	    }
	    _getValue_array(buffer, offset) {
	        const source = this.resolvedProperty;
	        for(let i = 0, n = source.length; i !== n; ++i){
	            buffer[offset++] = source[i];
	        }
	    }
	    _getValue_arrayElement(buffer, offset) {
	        buffer[offset] = this.resolvedProperty[this.propertyIndex];
	    }
	    _getValue_toArray(buffer, offset) {
	        this.resolvedProperty.toArray(buffer, offset);
	    }
	    // Direct
	    _setValue_direct(buffer, offset) {
	        this.targetObject[this.propertyName] = buffer[offset];
	    }
	    _setValue_direct_setNeedsUpdate(buffer, offset) {
	        this.targetObject[this.propertyName] = buffer[offset];
	        this.targetObject.needsUpdate = true;
	    }
	    _setValue_direct_setMatrixWorldNeedsUpdate(buffer, offset) {
	        this.targetObject[this.propertyName] = buffer[offset];
	        this.targetObject.matrixWorldNeedsUpdate = true;
	    }
	    // EntireArray
	    _setValue_array(buffer, offset) {
	        const dest = this.resolvedProperty;
	        for(let i = 0, n = dest.length; i !== n; ++i){
	            dest[i] = buffer[offset++];
	        }
	    }
	    _setValue_array_setNeedsUpdate(buffer, offset) {
	        const dest = this.resolvedProperty;
	        for(let i = 0, n = dest.length; i !== n; ++i){
	            dest[i] = buffer[offset++];
	        }
	        this.targetObject.needsUpdate = true;
	    }
	    _setValue_array_setMatrixWorldNeedsUpdate(buffer, offset) {
	        const dest = this.resolvedProperty;
	        for(let i = 0, n = dest.length; i !== n; ++i){
	            dest[i] = buffer[offset++];
	        }
	        this.targetObject.matrixWorldNeedsUpdate = true;
	    }
	    // ArrayElement
	    _setValue_arrayElement(buffer, offset) {
	        this.resolvedProperty[this.propertyIndex] = buffer[offset];
	    }
	    _setValue_arrayElement_setNeedsUpdate(buffer, offset) {
	        this.resolvedProperty[this.propertyIndex] = buffer[offset];
	        this.targetObject.needsUpdate = true;
	    }
	    _setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer, offset) {
	        this.resolvedProperty[this.propertyIndex] = buffer[offset];
	        this.targetObject.matrixWorldNeedsUpdate = true;
	    }
	    // HasToFromArray
	    _setValue_fromArray(buffer, offset) {
	        this.resolvedProperty.fromArray(buffer, offset);
	    }
	    _setValue_fromArray_setNeedsUpdate(buffer, offset) {
	        this.resolvedProperty.fromArray(buffer, offset);
	        this.targetObject.needsUpdate = true;
	    }
	    _setValue_fromArray_setMatrixWorldNeedsUpdate(buffer, offset) {
	        this.resolvedProperty.fromArray(buffer, offset);
	        this.targetObject.matrixWorldNeedsUpdate = true;
	    }
	    _getValue_unbound(targetArray, offset) {
	        this.bind();
	        this.getValue(targetArray, offset);
	    }
	    _setValue_unbound(sourceArray, offset) {
	        this.bind();
	        this.setValue(sourceArray, offset);
	    }
	    // create getter / setter pair for a property in the scene graph
	    bind() {
	        let targetObject = this.node;
	        const parsedPath = this.parsedPath;
	        const objectName = parsedPath.objectName;
	        const propertyName = parsedPath.propertyName;
	        let propertyIndex = parsedPath.propertyIndex;
	        if (!targetObject) {
	            targetObject = PropertyBinding.findNode(this.rootNode, parsedPath.nodeName);
	            this.node = targetObject;
	        }
	        // set fail state so we can just 'return' on error
	        this.getValue = this._getValue_unavailable;
	        this.setValue = this._setValue_unavailable;
	        // ensure there is a value node
	        if (!targetObject) {
	            console.warn('THREE.PropertyBinding: No target node found for track: ' + this.path + '.');
	            return;
	        }
	        if (objectName) {
	            let objectIndex = parsedPath.objectIndex;
	            // special cases were we need to reach deeper into the hierarchy to get the face materials....
	            switch(objectName){
	                case 'materials':
	                    if (!targetObject.material) {
	                        console.error('THREE.PropertyBinding: Can not bind to material as node does not have a material.', this);
	                        return;
	                    }
	                    if (!targetObject.material.materials) {
	                        console.error('THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this);
	                        return;
	                    }
	                    targetObject = targetObject.material.materials;
	                    break;
	                case 'bones':
	                    if (!targetObject.skeleton) {
	                        console.error('THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this);
	                        return;
	                    }
	                    // potential future optimization: skip this if propertyIndex is already an integer
	                    // and convert the integer string to a true integer.
	                    targetObject = targetObject.skeleton.bones;
	                    // support resolving morphTarget names into indices.
	                    for(let i = 0; i < targetObject.length; i++){
	                        if (targetObject[i].name === objectIndex) {
	                            objectIndex = i;
	                            break;
	                        }
	                    }
	                    break;
	                case 'map':
	                    if ('map' in targetObject) {
	                        targetObject = targetObject.map;
	                        break;
	                    }
	                    if (!targetObject.material) {
	                        console.error('THREE.PropertyBinding: Can not bind to material as node does not have a material.', this);
	                        return;
	                    }
	                    if (!targetObject.material.map) {
	                        console.error('THREE.PropertyBinding: Can not bind to material.map as node.material does not have a map.', this);
	                        return;
	                    }
	                    targetObject = targetObject.material.map;
	                    break;
	                default:
	                    if (targetObject[objectName] === undefined) {
	                        console.error('THREE.PropertyBinding: Can not bind to objectName of node undefined.', this);
	                        return;
	                    }
	                    targetObject = targetObject[objectName];
	            }
	            if (objectIndex !== undefined) {
	                if (targetObject[objectIndex] === undefined) {
	                    console.error('THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject);
	                    return;
	                }
	                targetObject = targetObject[objectIndex];
	            }
	        }
	        // resolve property
	        const nodeProperty = targetObject[propertyName];
	        if (nodeProperty === undefined) {
	            const nodeName = parsedPath.nodeName;
	            console.error('THREE.PropertyBinding: Trying to update property for track: ' + nodeName + '.' + propertyName + ' but it wasn\'t found.', targetObject);
	            return;
	        }
	        // determine versioning scheme
	        let versioning = this.Versioning.None;
	        this.targetObject = targetObject;
	        if (targetObject.isMaterial === true) {
	            versioning = this.Versioning.NeedsUpdate;
	        } else if (targetObject.isObject3D === true) {
	            versioning = this.Versioning.MatrixWorldNeedsUpdate;
	        }
	        // determine how the property gets bound
	        let bindingType = this.BindingType.Direct;
	        if (propertyIndex !== undefined) {
	            // access a sub element of the property array (only primitives are supported right now)
	            if (propertyName === 'morphTargetInfluences') {
	                // potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.
	                // support resolving morphTarget names into indices.
	                if (!targetObject.geometry) {
	                    console.error('THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this);
	                    return;
	                }
	                if (!targetObject.geometry.morphAttributes) {
	                    console.error('THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this);
	                    return;
	                }
	                if (targetObject.morphTargetDictionary[propertyIndex] !== undefined) {
	                    propertyIndex = targetObject.morphTargetDictionary[propertyIndex];
	                }
	            }
	            bindingType = this.BindingType.ArrayElement;
	            this.resolvedProperty = nodeProperty;
	            this.propertyIndex = propertyIndex;
	        } else if (nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined) {
	            // must use copy for Object3D.Euler/Quaternion
	            bindingType = this.BindingType.HasFromToArray;
	            this.resolvedProperty = nodeProperty;
	        } else if (Array.isArray(nodeProperty)) {
	            bindingType = this.BindingType.EntireArray;
	            this.resolvedProperty = nodeProperty;
	        } else {
	            this.propertyName = propertyName;
	        }
	        // select getter / setter
	        this.getValue = this.GetterByBindingType[bindingType];
	        this.setValue = this.SetterByBindingTypeAndVersioning[bindingType][versioning];
	    }
	    unbind() {
	        this.node = null;
	        // back to the prototype version of getValue / setValue
	        // note: avoiding to mutate the shape of 'this' via 'delete'
	        this.getValue = this._getValue_unbound;
	        this.setValue = this._setValue_unbound;
	    }
	    constructor(rootNode, path, parsedPath){
	        this.path = path;
	        this.parsedPath = parsedPath || PropertyBinding.parseTrackName(path);
	        this.node = PropertyBinding.findNode(rootNode, this.parsedPath.nodeName);
	        this.rootNode = rootNode;
	        // initial state of these methods that calls 'bind'
	        this.getValue = this._getValue_unbound;
	        this.setValue = this._setValue_unbound;
	    }
	}
	PropertyBinding.Composite = Composite;
	PropertyBinding.prototype.BindingType = {
	    Direct: 0,
	    EntireArray: 1,
	    ArrayElement: 2,
	    HasFromToArray: 3
	};
	PropertyBinding.prototype.Versioning = {
	    None: 0,
	    NeedsUpdate: 1,
	    MatrixWorldNeedsUpdate: 2
	};
	PropertyBinding.prototype.GetterByBindingType = [
	    PropertyBinding.prototype._getValue_direct,
	    PropertyBinding.prototype._getValue_array,
	    PropertyBinding.prototype._getValue_arrayElement,
	    PropertyBinding.prototype._getValue_toArray
	];
	PropertyBinding.prototype.SetterByBindingTypeAndVersioning = [
	    [
	        // Direct
	        PropertyBinding.prototype._setValue_direct,
	        PropertyBinding.prototype._setValue_direct_setNeedsUpdate,
	        PropertyBinding.prototype._setValue_direct_setMatrixWorldNeedsUpdate
	    ],
	    [
	        // EntireArray
	        PropertyBinding.prototype._setValue_array,
	        PropertyBinding.prototype._setValue_array_setNeedsUpdate,
	        PropertyBinding.prototype._setValue_array_setMatrixWorldNeedsUpdate
	    ],
	    [
	        // ArrayElement
	        PropertyBinding.prototype._setValue_arrayElement,
	        PropertyBinding.prototype._setValue_arrayElement_setNeedsUpdate,
	        PropertyBinding.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate
	    ],
	    [
	        // HasToFromArray
	        PropertyBinding.prototype._setValue_fromArray,
	        PropertyBinding.prototype._setValue_fromArray_setNeedsUpdate,
	        PropertyBinding.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate
	    ]
	];
	class AnimationAction {
	    // State & Scheduling
	    play() {
	        this._mixer._activateAction(this);
	        return this;
	    }
	    stop() {
	        this._mixer._deactivateAction(this);
	        return this.reset();
	    }
	    reset() {
	        this.paused = false;
	        this.enabled = true;
	        this.time = 0; // restart clip
	        this._loopCount = -1; // forget previous loops
	        this._startTime = null; // forget scheduling
	        return this.stopFading().stopWarping();
	    }
	    isRunning() {
	        return this.enabled && !this.paused && this.timeScale !== 0 && this._startTime === null && this._mixer._isActiveAction(this);
	    }
	    // return true when play has been called
	    isScheduled() {
	        return this._mixer._isActiveAction(this);
	    }
	    startAt(time) {
	        this._startTime = time;
	        return this;
	    }
	    setLoop(mode, repetitions) {
	        this.loop = mode;
	        this.repetitions = repetitions;
	        return this;
	    }
	    // Weight
	    // set the weight stopping any scheduled fading
	    // although .enabled = false yields an effective weight of zero, this
	    // method does *not* change .enabled, because it would be confusing
	    setEffectiveWeight(weight) {
	        this.weight = weight;
	        // note: same logic as when updated at runtime
	        this._effectiveWeight = this.enabled ? weight : 0;
	        return this.stopFading();
	    }
	    // return the weight considering fading and .enabled
	    getEffectiveWeight() {
	        return this._effectiveWeight;
	    }
	    fadeIn(duration) {
	        return this._scheduleFading(duration, 0, 1);
	    }
	    fadeOut(duration) {
	        return this._scheduleFading(duration, 1, 0);
	    }
	    crossFadeFrom(fadeOutAction, duration, warp) {
	        fadeOutAction.fadeOut(duration);
	        this.fadeIn(duration);
	        if (warp) {
	            const fadeInDuration = this._clip.duration, fadeOutDuration = fadeOutAction._clip.duration, startEndRatio = fadeOutDuration / fadeInDuration, endStartRatio = fadeInDuration / fadeOutDuration;
	            fadeOutAction.warp(1.0, startEndRatio, duration);
	            this.warp(endStartRatio, 1.0, duration);
	        }
	        return this;
	    }
	    crossFadeTo(fadeInAction, duration, warp) {
	        return fadeInAction.crossFadeFrom(this, duration, warp);
	    }
	    stopFading() {
	        const weightInterpolant = this._weightInterpolant;
	        if (weightInterpolant !== null) {
	            this._weightInterpolant = null;
	            this._mixer._takeBackControlInterpolant(weightInterpolant);
	        }
	        return this;
	    }
	    // Time Scale Control
	    // set the time scale stopping any scheduled warping
	    // although .paused = true yields an effective time scale of zero, this
	    // method does *not* change .paused, because it would be confusing
	    setEffectiveTimeScale(timeScale) {
	        this.timeScale = timeScale;
	        this._effectiveTimeScale = this.paused ? 0 : timeScale;
	        return this.stopWarping();
	    }
	    // return the time scale considering warping and .paused
	    getEffectiveTimeScale() {
	        return this._effectiveTimeScale;
	    }
	    setDuration(duration) {
	        this.timeScale = this._clip.duration / duration;
	        return this.stopWarping();
	    }
	    syncWith(action) {
	        this.time = action.time;
	        this.timeScale = action.timeScale;
	        return this.stopWarping();
	    }
	    halt(duration) {
	        return this.warp(this._effectiveTimeScale, 0, duration);
	    }
	    warp(startTimeScale, endTimeScale, duration) {
	        const mixer = this._mixer, now = mixer.time, timeScale = this.timeScale;
	        let interpolant = this._timeScaleInterpolant;
	        if (interpolant === null) {
	            interpolant = mixer._lendControlInterpolant();
	            this._timeScaleInterpolant = interpolant;
	        }
	        const times = interpolant.parameterPositions, values = interpolant.sampleValues;
	        times[0] = now;
	        times[1] = now + duration;
	        values[0] = startTimeScale / timeScale;
	        values[1] = endTimeScale / timeScale;
	        return this;
	    }
	    stopWarping() {
	        const timeScaleInterpolant = this._timeScaleInterpolant;
	        if (timeScaleInterpolant !== null) {
	            this._timeScaleInterpolant = null;
	            this._mixer._takeBackControlInterpolant(timeScaleInterpolant);
	        }
	        return this;
	    }
	    // Object Accessors
	    getMixer() {
	        return this._mixer;
	    }
	    getClip() {
	        return this._clip;
	    }
	    getRoot() {
	        return this._localRoot || this._mixer._root;
	    }
	    // Interna
	    _update(time, deltaTime, timeDirection, accuIndex) {
	        // called by the mixer
	        if (!this.enabled) {
	            // call ._updateWeight() to update ._effectiveWeight
	            this._updateWeight(time);
	            return;
	        }
	        const startTime = this._startTime;
	        if (startTime !== null) {
	            // check for scheduled start of action
	            const timeRunning = (time - startTime) * timeDirection;
	            if (timeRunning < 0 || timeDirection === 0) {
	                deltaTime = 0;
	            } else {
	                this._startTime = null; // unschedule
	                deltaTime = timeDirection * timeRunning;
	            }
	        }
	        // apply time scale and advance time
	        deltaTime *= this._updateTimeScale(time);
	        const clipTime = this._updateTime(deltaTime);
	        // note: _updateTime may disable the action resulting in
	        // an effective weight of 0
	        const weight = this._updateWeight(time);
	        if (weight > 0) {
	            const interpolants = this._interpolants;
	            const propertyMixers = this._propertyBindings;
	            switch(this.blendMode){
	                case AdditiveAnimationBlendMode:
	                    for(let j = 0, m = interpolants.length; j !== m; ++j){
	                        interpolants[j].evaluate(clipTime);
	                        propertyMixers[j].accumulateAdditive(weight);
	                    }
	                    break;
	                case NormalAnimationBlendMode:
	                default:
	                    for(let j = 0, m = interpolants.length; j !== m; ++j){
	                        interpolants[j].evaluate(clipTime);
	                        propertyMixers[j].accumulate(accuIndex, weight);
	                    }
	            }
	        }
	    }
	    _updateWeight(time) {
	        let weight = 0;
	        if (this.enabled) {
	            weight = this.weight;
	            const interpolant = this._weightInterpolant;
	            if (interpolant !== null) {
	                const interpolantValue = interpolant.evaluate(time)[0];
	                weight *= interpolantValue;
	                if (time > interpolant.parameterPositions[1]) {
	                    this.stopFading();
	                    if (interpolantValue === 0) {
	                        // faded out, disable
	                        this.enabled = false;
	                    }
	                }
	            }
	        }
	        this._effectiveWeight = weight;
	        return weight;
	    }
	    _updateTimeScale(time) {
	        let timeScale = 0;
	        if (!this.paused) {
	            timeScale = this.timeScale;
	            const interpolant = this._timeScaleInterpolant;
	            if (interpolant !== null) {
	                const interpolantValue = interpolant.evaluate(time)[0];
	                timeScale *= interpolantValue;
	                if (time > interpolant.parameterPositions[1]) {
	                    this.stopWarping();
	                    if (timeScale === 0) {
	                        // motion has halted, pause
	                        this.paused = true;
	                    } else {
	                        // warp done - apply final time scale
	                        this.timeScale = timeScale;
	                    }
	                }
	            }
	        }
	        this._effectiveTimeScale = timeScale;
	        return timeScale;
	    }
	    _updateTime(deltaTime) {
	        const duration = this._clip.duration;
	        const loop = this.loop;
	        let time = this.time + deltaTime;
	        let loopCount = this._loopCount;
	        const pingPong = loop === LoopPingPong;
	        if (deltaTime === 0) {
	            if (loopCount === -1) return time;
	            return pingPong && (loopCount & 1) === 1 ? duration - time : time;
	        }
	        if (loop === LoopOnce) {
	            if (loopCount === -1) {
	                // just started
	                this._loopCount = 0;
	                this._setEndings(true, true, false);
	            }
	            handle_stop: {
	                if (time >= duration) {
	                    time = duration;
	                } else if (time < 0) {
	                    time = 0;
	                } else {
	                    this.time = time;
	                    break handle_stop;
	                }
	                if (this.clampWhenFinished) this.paused = true;
	                else this.enabled = false;
	                this.time = time;
	                this._mixer.dispatchEvent({
	                    type: 'finished',
	                    action: this,
	                    direction: deltaTime < 0 ? -1 : 1
	                });
	            }
	        } else {
	            if (loopCount === -1) {
	                // just started
	                if (deltaTime >= 0) {
	                    loopCount = 0;
	                    this._setEndings(true, this.repetitions === 0, pingPong);
	                } else {
	                    // when looping in reverse direction, the initial
	                    // transition through zero counts as a repetition,
	                    // so leave loopCount at -1
	                    this._setEndings(this.repetitions === 0, true, pingPong);
	                }
	            }
	            if (time >= duration || time < 0) {
	                // wrap around
	                const loopDelta = Math.floor(time / duration); // signed
	                time -= duration * loopDelta;
	                loopCount += Math.abs(loopDelta);
	                const pending = this.repetitions - loopCount;
	                if (pending <= 0) {
	                    // have to stop (switch state, clamp time, fire event)
	                    if (this.clampWhenFinished) this.paused = true;
	                    else this.enabled = false;
	                    time = deltaTime > 0 ? duration : 0;
	                    this.time = time;
	                    this._mixer.dispatchEvent({
	                        type: 'finished',
	                        action: this,
	                        direction: deltaTime > 0 ? 1 : -1
	                    });
	                } else {
	                    // keep running
	                    if (pending === 1) {
	                        // entering the last round
	                        const atStart = deltaTime < 0;
	                        this._setEndings(atStart, !atStart, pingPong);
	                    } else {
	                        this._setEndings(false, false, pingPong);
	                    }
	                    this._loopCount = loopCount;
	                    this.time = time;
	                    this._mixer.dispatchEvent({
	                        type: 'loop',
	                        action: this,
	                        loopDelta: loopDelta
	                    });
	                }
	            } else {
	                this.time = time;
	            }
	            if (pingPong && (loopCount & 1) === 1) {
	                // invert time for the "pong round"
	                return duration - time;
	            }
	        }
	        return time;
	    }
	    _setEndings(atStart, atEnd, pingPong) {
	        const settings = this._interpolantSettings;
	        if (pingPong) {
	            settings.endingStart = ZeroSlopeEnding;
	            settings.endingEnd = ZeroSlopeEnding;
	        } else {
	            // assuming for LoopOnce atStart == atEnd == true
	            if (atStart) {
	                settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;
	            } else {
	                settings.endingStart = WrapAroundEnding;
	            }
	            if (atEnd) {
	                settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;
	            } else {
	                settings.endingEnd = WrapAroundEnding;
	            }
	        }
	    }
	    _scheduleFading(duration, weightNow, weightThen) {
	        const mixer = this._mixer, now = mixer.time;
	        let interpolant = this._weightInterpolant;
	        if (interpolant === null) {
	            interpolant = mixer._lendControlInterpolant();
	            this._weightInterpolant = interpolant;
	        }
	        const times = interpolant.parameterPositions, values = interpolant.sampleValues;
	        times[0] = now;
	        values[0] = weightNow;
	        times[1] = now + duration;
	        values[1] = weightThen;
	        return this;
	    }
	    constructor(mixer, clip, localRoot = null, blendMode = clip.blendMode){
	        this._mixer = mixer;
	        this._clip = clip;
	        this._localRoot = localRoot;
	        this.blendMode = blendMode;
	        const tracks = clip.tracks, nTracks = tracks.length, interpolants = new Array(nTracks);
	        const interpolantSettings = {
	            endingStart: ZeroCurvatureEnding,
	            endingEnd: ZeroCurvatureEnding
	        };
	        for(let i = 0; i !== nTracks; ++i){
	            const interpolant = tracks[i].createInterpolant(null);
	            interpolants[i] = interpolant;
	            interpolant.settings = interpolantSettings;
	        }
	        this._interpolantSettings = interpolantSettings;
	        this._interpolants = interpolants; // bound by the mixer
	        // inside: PropertyMixer (managed by the mixer)
	        this._propertyBindings = new Array(nTracks);
	        this._cacheIndex = null; // for the memory manager
	        this._byClipCacheIndex = null; // for the memory manager
	        this._timeScaleInterpolant = null;
	        this._weightInterpolant = null;
	        this.loop = LoopRepeat;
	        this._loopCount = -1;
	        // global mixer time when the action is to be started
	        // it's set back to 'null' upon start of the action
	        this._startTime = null;
	        // scaled local time of the action
	        // gets clamped or wrapped to 0..clip.duration according to loop
	        this.time = 0;
	        this.timeScale = 1;
	        this._effectiveTimeScale = 1;
	        this.weight = 1;
	        this._effectiveWeight = 1;
	        this.repetitions = Infinity; // no. of repetitions when looping
	        this.paused = false; // true -> zero effective time scale
	        this.enabled = true; // false -> zero effective weight
	        this.clampWhenFinished = false; // keep feeding the last frame?
	        this.zeroSlopeAtStart = true; // for smooth interpolation w/o separate
	        this.zeroSlopeAtEnd = true; // clips for start, loop and end
	    }
	}
	const _controlInterpolantsResultBuffer = new Float32Array(1);
	class AnimationMixer extends EventDispatcher {
	    _bindAction(action, prototypeAction) {
	        const root = action._localRoot || this._root, tracks = action._clip.tracks, nTracks = tracks.length, bindings = action._propertyBindings, interpolants = action._interpolants, rootUuid = root.uuid, bindingsByRoot = this._bindingsByRootAndName;
	        let bindingsByName = bindingsByRoot[rootUuid];
	        if (bindingsByName === undefined) {
	            bindingsByName = {};
	            bindingsByRoot[rootUuid] = bindingsByName;
	        }
	        for(let i = 0; i !== nTracks; ++i){
	            const track = tracks[i], trackName = track.name;
	            let binding = bindingsByName[trackName];
	            if (binding !== undefined) {
	                ++binding.referenceCount;
	                bindings[i] = binding;
	            } else {
	                binding = bindings[i];
	                if (binding !== undefined) {
	                    // existing binding, make sure the cache knows
	                    if (binding._cacheIndex === null) {
	                        ++binding.referenceCount;
	                        this._addInactiveBinding(binding, rootUuid, trackName);
	                    }
	                    continue;
	                }
	                const path = prototypeAction && prototypeAction._propertyBindings[i].binding.parsedPath;
	                binding = new PropertyMixer(PropertyBinding.create(root, trackName, path), track.ValueTypeName, track.getValueSize());
	                ++binding.referenceCount;
	                this._addInactiveBinding(binding, rootUuid, trackName);
	                bindings[i] = binding;
	            }
	            interpolants[i].resultBuffer = binding.buffer;
	        }
	    }
	    _activateAction(action) {
	        if (!this._isActiveAction(action)) {
	            if (action._cacheIndex === null) {
	                // this action has been forgotten by the cache, but the user
	                // appears to be still using it -> rebind
	                const rootUuid = (action._localRoot || this._root).uuid, clipUuid = action._clip.uuid, actionsForClip = this._actionsByClip[clipUuid];
	                this._bindAction(action, actionsForClip && actionsForClip.knownActions[0]);
	                this._addInactiveAction(action, clipUuid, rootUuid);
	            }
	            const bindings = action._propertyBindings;
	            // increment reference counts / sort out state
	            for(let i = 0, n = bindings.length; i !== n; ++i){
	                const binding = bindings[i];
	                if (binding.useCount++ === 0) {
	                    this._lendBinding(binding);
	                    binding.saveOriginalState();
	                }
	            }
	            this._lendAction(action);
	        }
	    }
	    _deactivateAction(action) {
	        if (this._isActiveAction(action)) {
	            const bindings = action._propertyBindings;
	            // decrement reference counts / sort out state
	            for(let i = 0, n = bindings.length; i !== n; ++i){
	                const binding = bindings[i];
	                if (--binding.useCount === 0) {
	                    binding.restoreOriginalState();
	                    this._takeBackBinding(binding);
	                }
	            }
	            this._takeBackAction(action);
	        }
	    }
	    // Memory manager
	    _initMemoryManager() {
	        this._actions = []; // 'nActiveActions' followed by inactive ones
	        this._nActiveActions = 0;
	        this._actionsByClip = {};
	        // inside:
	        // {
	        // 	knownActions: Array< AnimationAction > - used as prototypes
	        // 	actionByRoot: AnimationAction - lookup
	        // }
	        this._bindings = []; // 'nActiveBindings' followed by inactive ones
	        this._nActiveBindings = 0;
	        this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >
	        this._controlInterpolants = []; // same game as above
	        this._nActiveControlInterpolants = 0;
	        const scope = this;
	        this.stats = {
	            actions: {
	                get total () {
	                    return scope._actions.length;
	                },
	                get inUse () {
	                    return scope._nActiveActions;
	                }
	            },
	            bindings: {
	                get total () {
	                    return scope._bindings.length;
	                },
	                get inUse () {
	                    return scope._nActiveBindings;
	                }
	            },
	            controlInterpolants: {
	                get total () {
	                    return scope._controlInterpolants.length;
	                },
	                get inUse () {
	                    return scope._nActiveControlInterpolants;
	                }
	            }
	        };
	    }
	    // Memory management for AnimationAction objects
	    _isActiveAction(action) {
	        const index = action._cacheIndex;
	        return index !== null && index < this._nActiveActions;
	    }
	    _addInactiveAction(action, clipUuid, rootUuid) {
	        const actions = this._actions, actionsByClip = this._actionsByClip;
	        let actionsForClip = actionsByClip[clipUuid];
	        if (actionsForClip === undefined) {
	            actionsForClip = {
	                knownActions: [
	                    action
	                ],
	                actionByRoot: {}
	            };
	            action._byClipCacheIndex = 0;
	            actionsByClip[clipUuid] = actionsForClip;
	        } else {
	            const knownActions = actionsForClip.knownActions;
	            action._byClipCacheIndex = knownActions.length;
	            knownActions.push(action);
	        }
	        action._cacheIndex = actions.length;
	        actions.push(action);
	        actionsForClip.actionByRoot[rootUuid] = action;
	    }
	    _removeInactiveAction(action) {
	        const actions = this._actions, lastInactiveAction = actions[actions.length - 1], cacheIndex = action._cacheIndex;
	        lastInactiveAction._cacheIndex = cacheIndex;
	        actions[cacheIndex] = lastInactiveAction;
	        actions.pop();
	        action._cacheIndex = null;
	        const clipUuid = action._clip.uuid, actionsByClip = this._actionsByClip, actionsForClip = actionsByClip[clipUuid], knownActionsForClip = actionsForClip.knownActions, lastKnownAction = knownActionsForClip[knownActionsForClip.length - 1], byClipCacheIndex = action._byClipCacheIndex;
	        lastKnownAction._byClipCacheIndex = byClipCacheIndex;
	        knownActionsForClip[byClipCacheIndex] = lastKnownAction;
	        knownActionsForClip.pop();
	        action._byClipCacheIndex = null;
	        const actionByRoot = actionsForClip.actionByRoot, rootUuid = (action._localRoot || this._root).uuid;
	        delete actionByRoot[rootUuid];
	        if (knownActionsForClip.length === 0) {
	            delete actionsByClip[clipUuid];
	        }
	        this._removeInactiveBindingsForAction(action);
	    }
	    _removeInactiveBindingsForAction(action) {
	        const bindings = action._propertyBindings;
	        for(let i = 0, n = bindings.length; i !== n; ++i){
	            const binding = bindings[i];
	            if (--binding.referenceCount === 0) {
	                this._removeInactiveBinding(binding);
	            }
	        }
	    }
	    _lendAction(action) {
	        // [ active actions |  inactive actions  ]
	        // [  active actions >| inactive actions ]
	        //                 s        a
	        //                  <-swap->
	        //                 a        s
	        const actions = this._actions, prevIndex = action._cacheIndex, lastActiveIndex = this._nActiveActions++, firstInactiveAction = actions[lastActiveIndex];
	        action._cacheIndex = lastActiveIndex;
	        actions[lastActiveIndex] = action;
	        firstInactiveAction._cacheIndex = prevIndex;
	        actions[prevIndex] = firstInactiveAction;
	    }
	    _takeBackAction(action) {
	        // [  active actions  | inactive actions ]
	        // [ active actions |< inactive actions  ]
	        //        a        s
	        //         <-swap->
	        //        s        a
	        const actions = this._actions, prevIndex = action._cacheIndex, firstInactiveIndex = --this._nActiveActions, lastActiveAction = actions[firstInactiveIndex];
	        action._cacheIndex = firstInactiveIndex;
	        actions[firstInactiveIndex] = action;
	        lastActiveAction._cacheIndex = prevIndex;
	        actions[prevIndex] = lastActiveAction;
	    }
	    // Memory management for PropertyMixer objects
	    _addInactiveBinding(binding, rootUuid, trackName) {
	        const bindingsByRoot = this._bindingsByRootAndName, bindings = this._bindings;
	        let bindingByName = bindingsByRoot[rootUuid];
	        if (bindingByName === undefined) {
	            bindingByName = {};
	            bindingsByRoot[rootUuid] = bindingByName;
	        }
	        bindingByName[trackName] = binding;
	        binding._cacheIndex = bindings.length;
	        bindings.push(binding);
	    }
	    _removeInactiveBinding(binding) {
	        const bindings = this._bindings, propBinding = binding.binding, rootUuid = propBinding.rootNode.uuid, trackName = propBinding.path, bindingsByRoot = this._bindingsByRootAndName, bindingByName = bindingsByRoot[rootUuid], lastInactiveBinding = bindings[bindings.length - 1], cacheIndex = binding._cacheIndex;
	        lastInactiveBinding._cacheIndex = cacheIndex;
	        bindings[cacheIndex] = lastInactiveBinding;
	        bindings.pop();
	        delete bindingByName[trackName];
	        if (Object.keys(bindingByName).length === 0) {
	            delete bindingsByRoot[rootUuid];
	        }
	    }
	    _lendBinding(binding) {
	        const bindings = this._bindings, prevIndex = binding._cacheIndex, lastActiveIndex = this._nActiveBindings++, firstInactiveBinding = bindings[lastActiveIndex];
	        binding._cacheIndex = lastActiveIndex;
	        bindings[lastActiveIndex] = binding;
	        firstInactiveBinding._cacheIndex = prevIndex;
	        bindings[prevIndex] = firstInactiveBinding;
	    }
	    _takeBackBinding(binding) {
	        const bindings = this._bindings, prevIndex = binding._cacheIndex, firstInactiveIndex = --this._nActiveBindings, lastActiveBinding = bindings[firstInactiveIndex];
	        binding._cacheIndex = firstInactiveIndex;
	        bindings[firstInactiveIndex] = binding;
	        lastActiveBinding._cacheIndex = prevIndex;
	        bindings[prevIndex] = lastActiveBinding;
	    }
	    // Memory management of Interpolants for weight and time scale
	    _lendControlInterpolant() {
	        const interpolants = this._controlInterpolants, lastActiveIndex = this._nActiveControlInterpolants++;
	        let interpolant = interpolants[lastActiveIndex];
	        if (interpolant === undefined) {
	            interpolant = new LinearInterpolant(new Float32Array(2), new Float32Array(2), 1, _controlInterpolantsResultBuffer);
	            interpolant.__cacheIndex = lastActiveIndex;
	            interpolants[lastActiveIndex] = interpolant;
	        }
	        return interpolant;
	    }
	    _takeBackControlInterpolant(interpolant) {
	        const interpolants = this._controlInterpolants, prevIndex = interpolant.__cacheIndex, firstInactiveIndex = --this._nActiveControlInterpolants, lastActiveInterpolant = interpolants[firstInactiveIndex];
	        interpolant.__cacheIndex = firstInactiveIndex;
	        interpolants[firstInactiveIndex] = interpolant;
	        lastActiveInterpolant.__cacheIndex = prevIndex;
	        interpolants[prevIndex] = lastActiveInterpolant;
	    }
	    // return an action for a clip optionally using a custom root target
	    // object (this method allocates a lot of dynamic memory in case a
	    // previously unknown clip/root combination is specified)
	    clipAction(clip, optionalRoot, blendMode) {
	        const root = optionalRoot || this._root, rootUuid = root.uuid;
	        let clipObject = typeof clip === 'string' ? AnimationClip.findByName(root, clip) : clip;
	        const clipUuid = clipObject !== null ? clipObject.uuid : clip;
	        const actionsForClip = this._actionsByClip[clipUuid];
	        let prototypeAction = null;
	        if (blendMode === undefined) {
	            if (clipObject !== null) {
	                blendMode = clipObject.blendMode;
	            } else {
	                blendMode = NormalAnimationBlendMode;
	            }
	        }
	        if (actionsForClip !== undefined) {
	            const existingAction = actionsForClip.actionByRoot[rootUuid];
	            if (existingAction !== undefined && existingAction.blendMode === blendMode) {
	                return existingAction;
	            }
	            // we know the clip, so we don't have to parse all
	            // the bindings again but can just copy
	            prototypeAction = actionsForClip.knownActions[0];
	            // also, take the clip from the prototype action
	            if (clipObject === null) clipObject = prototypeAction._clip;
	        }
	        // clip must be known when specified via string
	        if (clipObject === null) return null;
	        // allocate all resources required to run it
	        const newAction = new AnimationAction(this, clipObject, optionalRoot, blendMode);
	        this._bindAction(newAction, prototypeAction);
	        // and make the action known to the memory manager
	        this._addInactiveAction(newAction, clipUuid, rootUuid);
	        return newAction;
	    }
	    // get an existing action
	    existingAction(clip, optionalRoot) {
	        const root = optionalRoot || this._root, rootUuid = root.uuid, clipObject = typeof clip === 'string' ? AnimationClip.findByName(root, clip) : clip, clipUuid = clipObject ? clipObject.uuid : clip, actionsForClip = this._actionsByClip[clipUuid];
	        if (actionsForClip !== undefined) {
	            return actionsForClip.actionByRoot[rootUuid] || null;
	        }
	        return null;
	    }
	    // deactivates all previously scheduled actions
	    stopAllAction() {
	        const actions = this._actions, nActions = this._nActiveActions;
	        for(let i = nActions - 1; i >= 0; --i){
	            actions[i].stop();
	        }
	        return this;
	    }
	    // advance the time and update apply the animation
	    update(deltaTime) {
	        deltaTime *= this.timeScale;
	        const actions = this._actions, nActions = this._nActiveActions, time = this.time += deltaTime, timeDirection = Math.sign(deltaTime), accuIndex = this._accuIndex ^= 1;
	        // run active actions
	        for(let i = 0; i !== nActions; ++i){
	            const action = actions[i];
	            action._update(time, deltaTime, timeDirection, accuIndex);
	        }
	        // update scene graph
	        const bindings = this._bindings, nBindings = this._nActiveBindings;
	        for(let i = 0; i !== nBindings; ++i){
	            bindings[i].apply(accuIndex);
	        }
	        return this;
	    }
	    // Allows you to seek to a specific time in an animation.
	    setTime(timeInSeconds) {
	        this.time = 0; // Zero out time attribute for AnimationMixer object;
	        for(let i = 0; i < this._actions.length; i++){
	            this._actions[i].time = 0; // Zero out time attribute for all associated AnimationAction objects.
	        }
	        return this.update(timeInSeconds); // Update used to set exact time. Returns "this" AnimationMixer object.
	    }
	    // return this mixer's root target object
	    getRoot() {
	        return this._root;
	    }
	    // free all resources specific to a particular clip
	    uncacheClip(clip) {
	        const actions = this._actions, clipUuid = clip.uuid, actionsByClip = this._actionsByClip, actionsForClip = actionsByClip[clipUuid];
	        if (actionsForClip !== undefined) {
	            // note: just calling _removeInactiveAction would mess up the
	            // iteration state and also require updating the state we can
	            // just throw away
	            const actionsToRemove = actionsForClip.knownActions;
	            for(let i = 0, n = actionsToRemove.length; i !== n; ++i){
	                const action = actionsToRemove[i];
	                this._deactivateAction(action);
	                const cacheIndex = action._cacheIndex, lastInactiveAction = actions[actions.length - 1];
	                action._cacheIndex = null;
	                action._byClipCacheIndex = null;
	                lastInactiveAction._cacheIndex = cacheIndex;
	                actions[cacheIndex] = lastInactiveAction;
	                actions.pop();
	                this._removeInactiveBindingsForAction(action);
	            }
	            delete actionsByClip[clipUuid];
	        }
	    }
	    // free all resources specific to a particular root target object
	    uncacheRoot(root) {
	        const rootUuid = root.uuid, actionsByClip = this._actionsByClip;
	        for(const clipUuid in actionsByClip){
	            const actionByRoot = actionsByClip[clipUuid].actionByRoot, action = actionByRoot[rootUuid];
	            if (action !== undefined) {
	                this._deactivateAction(action);
	                this._removeInactiveAction(action);
	            }
	        }
	        const bindingsByRoot = this._bindingsByRootAndName, bindingByName = bindingsByRoot[rootUuid];
	        if (bindingByName !== undefined) {
	            for(const trackName in bindingByName){
	                const binding = bindingByName[trackName];
	                binding.restoreOriginalState();
	                this._removeInactiveBinding(binding);
	            }
	        }
	    }
	    // remove a targeted clip from the cache
	    uncacheAction(clip, optionalRoot) {
	        const action = this.existingAction(clip, optionalRoot);
	        if (action !== null) {
	            this._deactivateAction(action);
	            this._removeInactiveAction(action);
	        }
	    }
	    constructor(root){
	        super();
	        this._root = root;
	        this._initMemoryManager();
	        this._accuIndex = 0;
	        this.time = 0;
	        this.timeScale = 1.0;
	    }
	}
	const _matrix = /*@__PURE__*/ new Matrix4();
	class Raycaster {
	    set(origin, direction) {
	        // direction is assumed to be normalized (for accurate distance calculations)
	        this.ray.set(origin, direction);
	    }
	    setFromCamera(coords, camera) {
	        if (camera.isPerspectiveCamera) {
	            this.ray.origin.setFromMatrixPosition(camera.matrixWorld);
	            this.ray.direction.set(coords.x, coords.y, 0.5).unproject(camera).sub(this.ray.origin).normalize();
	            this.camera = camera;
	        } else if (camera.isOrthographicCamera) {
	            this.ray.origin.set(coords.x, coords.y, (camera.near + camera.far) / (camera.near - camera.far)).unproject(camera); // set origin in plane of camera
	            this.ray.direction.set(0, 0, -1).transformDirection(camera.matrixWorld);
	            this.camera = camera;
	        } else {
	            console.error('THREE.Raycaster: Unsupported camera type: ' + camera.type);
	        }
	    }
	    setFromXRController(controller) {
	        _matrix.identity().extractRotation(controller.matrixWorld);
	        this.ray.origin.setFromMatrixPosition(controller.matrixWorld);
	        this.ray.direction.set(0, 0, -1).applyMatrix4(_matrix);
	        return this;
	    }
	    intersectObject(object, recursive = true, intersects = []) {
	        intersect(object, this, intersects, recursive);
	        intersects.sort(ascSort);
	        return intersects;
	    }
	    intersectObjects(objects, recursive = true, intersects = []) {
	        for(let i = 0, l = objects.length; i < l; i++){
	            intersect(objects[i], this, intersects, recursive);
	        }
	        intersects.sort(ascSort);
	        return intersects;
	    }
	    constructor(origin, direction, near = 0, far = Infinity){
	        this.ray = new Ray(origin, direction);
	        // direction is assumed to be normalized (for accurate distance calculations)
	        this.near = near;
	        this.far = far;
	        this.camera = null;
	        this.layers = new Layers();
	        this.params = {
	            Mesh: {},
	            Line: {
	                threshold: 1
	            },
	            LOD: {},
	            Points: {
	                threshold: 1
	            },
	            Sprite: {}
	        };
	    }
	}
	function ascSort(a, b) {
	    return a.distance - b.distance;
	}
	function intersect(object, raycaster, intersects, recursive) {
	    let propagate = true;
	    if (object.layers.test(raycaster.layers)) {
	        const result = object.raycast(raycaster, intersects);
	        if (result === false) propagate = false;
	    }
	    if (propagate === true && recursive === true) {
	        const children = object.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            intersect(children[i], raycaster, intersects, true);
	        }
	    }
	}
	/**
	 * This class can be used to represent points in 3D space as
	 * [Spherical coordinates]{@link https://en.wikipedia.org/wiki/Spherical_coordinate_system}.
	 */ class Spherical {
	    /**
		 * Sets the spherical components by copying the given values.
		 *
		 * @param {number} radius - The radius.
		 * @param {number} phi - The polar angle.
		 * @param {number} theta - The azimuthal angle.
		 * @return {Spherical} A reference to this spherical.
		 */ set(radius, phi, theta) {
	        this.radius = radius;
	        this.phi = phi;
	        this.theta = theta;
	        return this;
	    }
	    /**
		 * Copies the values of the given spherical to this instance.
		 *
		 * @param {Spherical} other - The spherical to copy.
		 * @return {Spherical} A reference to this spherical.
		 */ copy(other) {
	        this.radius = other.radius;
	        this.phi = other.phi;
	        this.theta = other.theta;
	        return this;
	    }
	    /**
		 * Restricts the polar angle [page:.phi phi] to be between `0.000001` and pi -
		 * `0.000001`.
		 *
		 * @return {Spherical} A reference to this spherical.
		 */ makeSafe() {
	        const EPS = 0.000001;
	        this.phi = clamp$1(this.phi, EPS, Math.PI - EPS);
	        return this;
	    }
	    /**
		 * Sets the spherical components from the given vector which is assumed to hold
		 * Cartesian coordinates.
		 *
		 * @param {Vector3} v - The vector to set.
		 * @return {Spherical} A reference to this spherical.
		 */ setFromVector3(v) {
	        return this.setFromCartesianCoords(v.x, v.y, v.z);
	    }
	    /**
		 * Sets the spherical components from the given Cartesian coordinates.
		 *
		 * @param {number} x - The x value.
		 * @param {number} y - The x value.
		 * @param {number} z - The x value.
		 * @return {Spherical} A reference to this spherical.
		 */ setFromCartesianCoords(x, y, z) {
	        this.radius = Math.sqrt(x * x + y * y + z * z);
	        if (this.radius === 0) {
	            this.theta = 0;
	            this.phi = 0;
	        } else {
	            this.theta = Math.atan2(x, z);
	            this.phi = Math.acos(clamp$1(y / this.radius, -1, 1));
	        }
	        return this;
	    }
	    /**
		 * Returns a new spherical with copied values from this instance.
		 *
		 * @return {Spherical} A clone of this instance.
		 */ clone() {
	        return new this.constructor().copy(this);
	    }
	    /**
		 * Constructs a new spherical.
		 *
		 * @param {number} [radius=1] - The radius, or the Euclidean distance (straight-line distance) from the point to the origin.
		 * @param {number} [phi=0] - The polar angle in radians from the y (up) axis.
		 * @param {number} [theta=0] - The equator/azimuthal angle in radians around the y (up) axis.
		 */ constructor(radius = 1, phi = 0, theta = 0){
	        /**
			 * The radius, or the Euclidean distance (straight-line distance) from the point to the origin.
			 *
			 * @type {number}
			 * @default 1
			 */ this.radius = radius;
	        /**
			 * The polar angle in radians from the y (up) axis.
			 *
			 * @type {number}
			 * @default 0
			 */ this.phi = phi;
	        /**
			 * The equator/azimuthal angle in radians around the y (up) axis.
			 *
			 * @type {number}
			 * @default 0
			 */ this.theta = theta;
	    }
	}
	/**
	 * Determines how many bytes must be used to represent the texture.
	 *
	 * @param {number} width - The width of the texture.
	 * @param {number} height - The height of the texture.
	 * @param {number} format - The texture's format.
	 * @param {number} type - The texture's type.
	 * @return {number} The byte length.
	 */ function getByteLength(width, height, format, type) {
	    const typeByteLength = getTextureTypeByteLength(type);
	    switch(format){
	        // https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glTexImage2D.xhtml
	        case AlphaFormat:
	            return width * height;
	        case LuminanceFormat:
	            return width * height;
	        case LuminanceAlphaFormat:
	            return width * height * 2;
	        case RedFormat:
	            return width * height / typeByteLength.components * typeByteLength.byteLength;
	        case RedIntegerFormat:
	            return width * height / typeByteLength.components * typeByteLength.byteLength;
	        case RGFormat:
	            return width * height * 2 / typeByteLength.components * typeByteLength.byteLength;
	        case RGIntegerFormat:
	            return width * height * 2 / typeByteLength.components * typeByteLength.byteLength;
	        case RGBFormat:
	            return width * height * 3 / typeByteLength.components * typeByteLength.byteLength;
	        case RGBAFormat:
	            return width * height * 4 / typeByteLength.components * typeByteLength.byteLength;
	        case RGBAIntegerFormat:
	            return width * height * 4 / typeByteLength.components * typeByteLength.byteLength;
	        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_s3tc_srgb/
	        case RGB_S3TC_DXT1_Format:
	        case RGBA_S3TC_DXT1_Format:
	            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
	        case RGBA_S3TC_DXT3_Format:
	        case RGBA_S3TC_DXT5_Format:
	            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
	        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_pvrtc/
	        case RGB_PVRTC_2BPPV1_Format:
	        case RGBA_PVRTC_2BPPV1_Format:
	            return Math.max(width, 16) * Math.max(height, 8) / 4;
	        case RGB_PVRTC_4BPPV1_Format:
	        case RGBA_PVRTC_4BPPV1_Format:
	            return Math.max(width, 8) * Math.max(height, 8) / 2;
	        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_etc/
	        case RGB_ETC1_Format:
	        case RGB_ETC2_Format:
	            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
	        case RGBA_ETC2_EAC_Format:
	            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
	        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_astc/
	        case RGBA_ASTC_4x4_Format:
	            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
	        case RGBA_ASTC_5x4_Format:
	            return Math.floor((width + 4) / 5) * Math.floor((height + 3) / 4) * 16;
	        case RGBA_ASTC_5x5_Format:
	            return Math.floor((width + 4) / 5) * Math.floor((height + 4) / 5) * 16;
	        case RGBA_ASTC_6x5_Format:
	            return Math.floor((width + 5) / 6) * Math.floor((height + 4) / 5) * 16;
	        case RGBA_ASTC_6x6_Format:
	            return Math.floor((width + 5) / 6) * Math.floor((height + 5) / 6) * 16;
	        case RGBA_ASTC_8x5_Format:
	            return Math.floor((width + 7) / 8) * Math.floor((height + 4) / 5) * 16;
	        case RGBA_ASTC_8x6_Format:
	            return Math.floor((width + 7) / 8) * Math.floor((height + 5) / 6) * 16;
	        case RGBA_ASTC_8x8_Format:
	            return Math.floor((width + 7) / 8) * Math.floor((height + 7) / 8) * 16;
	        case RGBA_ASTC_10x5_Format:
	            return Math.floor((width + 9) / 10) * Math.floor((height + 4) / 5) * 16;
	        case RGBA_ASTC_10x6_Format:
	            return Math.floor((width + 9) / 10) * Math.floor((height + 5) / 6) * 16;
	        case RGBA_ASTC_10x8_Format:
	            return Math.floor((width + 9) / 10) * Math.floor((height + 7) / 8) * 16;
	        case RGBA_ASTC_10x10_Format:
	            return Math.floor((width + 9) / 10) * Math.floor((height + 9) / 10) * 16;
	        case RGBA_ASTC_12x10_Format:
	            return Math.floor((width + 11) / 12) * Math.floor((height + 9) / 10) * 16;
	        case RGBA_ASTC_12x12_Format:
	            return Math.floor((width + 11) / 12) * Math.floor((height + 11) / 12) * 16;
	        // https://registry.khronos.org/webgl/extensions/EXT_texture_compression_bptc/
	        case RGBA_BPTC_Format:
	        case RGB_BPTC_SIGNED_Format:
	        case RGB_BPTC_UNSIGNED_Format:
	            return Math.ceil(width / 4) * Math.ceil(height / 4) * 16;
	        // https://registry.khronos.org/webgl/extensions/EXT_texture_compression_rgtc/
	        case RED_RGTC1_Format:
	        case SIGNED_RED_RGTC1_Format:
	            return Math.ceil(width / 4) * Math.ceil(height / 4) * 8;
	        case RED_GREEN_RGTC2_Format:
	        case SIGNED_RED_GREEN_RGTC2_Format:
	            return Math.ceil(width / 4) * Math.ceil(height / 4) * 16;
	    }
	    throw new Error(`Unable to determine texture byte length for ${format} format.`);
	}
	function getTextureTypeByteLength(type) {
	    switch(type){
	        case UnsignedByteType:
	        case ByteType:
	            return {
	                byteLength: 1,
	                components: 1
	            };
	        case UnsignedShortType:
	        case ShortType:
	        case HalfFloatType:
	            return {
	                byteLength: 2,
	                components: 1
	            };
	        case UnsignedShort4444Type:
	        case UnsignedShort5551Type:
	            return {
	                byteLength: 2,
	                components: 4
	            };
	        case UnsignedIntType:
	        case IntType:
	        case FloatType:
	            return {
	                byteLength: 4,
	                components: 1
	            };
	        case UnsignedInt5999Type:
	            return {
	                byteLength: 4,
	                components: 3
	            };
	    }
	    throw new Error(`Unknown texture type ${type}.`);
	}
	if (typeof __THREE_DEVTOOLS__ !== 'undefined') {
	    __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent('register', {
	        detail: {
	            revision: REVISION
	        }
	    }));
	}
	if (typeof window !== 'undefined') {
	    if (window.__THREE__) {
	        console.warn('WARNING: Multiple instances of Three.js being imported.');
	    } else {
	        window.__THREE__ = REVISION;
	    }
	}

	function WebGLAnimation() {
	    let context = null;
	    let isAnimating = false;
	    let animationLoop = null;
	    let requestId = null;
	    function onAnimationFrame(time, frame) {
	        animationLoop(time, frame);
	        requestId = context.requestAnimationFrame(onAnimationFrame);
	    }
	    return {
	        start: function() {
	            if (isAnimating === true) return;
	            if (animationLoop === null) return;
	            requestId = context.requestAnimationFrame(onAnimationFrame);
	            isAnimating = true;
	        },
	        stop: function() {
	            context.cancelAnimationFrame(requestId);
	            isAnimating = false;
	        },
	        setAnimationLoop: function(callback) {
	            animationLoop = callback;
	        },
	        setContext: function(value) {
	            context = value;
	        }
	    };
	}
	function WebGLAttributes(gl) {
	    const buffers = new WeakMap();
	    function createBuffer(attribute, bufferType) {
	        const array = attribute.array;
	        const usage = attribute.usage;
	        const size = array.byteLength;
	        const buffer = gl.createBuffer();
	        gl.bindBuffer(bufferType, buffer);
	        gl.bufferData(bufferType, array, usage);
	        attribute.onUploadCallback();
	        let type;
	        if (array instanceof Float32Array) {
	            type = gl.FLOAT;
	        } else if (array instanceof Uint16Array) {
	            if (attribute.isFloat16BufferAttribute) {
	                type = gl.HALF_FLOAT;
	            } else {
	                type = gl.UNSIGNED_SHORT;
	            }
	        } else if (array instanceof Int16Array) {
	            type = gl.SHORT;
	        } else if (array instanceof Uint32Array) {
	            type = gl.UNSIGNED_INT;
	        } else if (array instanceof Int32Array) {
	            type = gl.INT;
	        } else if (array instanceof Int8Array) {
	            type = gl.BYTE;
	        } else if (array instanceof Uint8Array) {
	            type = gl.UNSIGNED_BYTE;
	        } else if (array instanceof Uint8ClampedArray) {
	            type = gl.UNSIGNED_BYTE;
	        } else {
	            throw new Error('THREE.WebGLAttributes: Unsupported buffer data format: ' + array);
	        }
	        return {
	            buffer: buffer,
	            type: type,
	            bytesPerElement: array.BYTES_PER_ELEMENT,
	            version: attribute.version,
	            size: size
	        };
	    }
	    function updateBuffer(buffer, attribute, bufferType) {
	        const array = attribute.array;
	        const updateRanges = attribute.updateRanges;
	        gl.bindBuffer(bufferType, buffer);
	        if (updateRanges.length === 0) {
	            // Not using update ranges
	            gl.bufferSubData(bufferType, 0, array);
	        } else {
	            // Before applying update ranges, we merge any adjacent / overlapping
	            // ranges to reduce load on `gl.bufferSubData`. Empirically, this has led
	            // to performance improvements for applications which make heavy use of
	            // update ranges. Likely due to GPU command overhead.
	            //
	            // Note that to reduce garbage collection between frames, we merge the
	            // update ranges in-place. This is safe because this method will clear the
	            // update ranges once updated.
	            updateRanges.sort((a, b)=>a.start - b.start);
	            // To merge the update ranges in-place, we work from left to right in the
	            // existing updateRanges array, merging ranges. This may result in a final
	            // array which is smaller than the original. This index tracks the last
	            // index representing a merged range, any data after this index can be
	            // trimmed once the merge algorithm is completed.
	            let mergeIndex = 0;
	            for(let i = 1; i < updateRanges.length; i++){
	                const previousRange = updateRanges[mergeIndex];
	                const range = updateRanges[i];
	                // We add one here to merge adjacent ranges. This is safe because ranges
	                // operate over positive integers.
	                if (range.start <= previousRange.start + previousRange.count + 1) {
	                    previousRange.count = Math.max(previousRange.count, range.start + range.count - previousRange.start);
	                } else {
	                    ++mergeIndex;
	                    updateRanges[mergeIndex] = range;
	                }
	            }
	            // Trim the array to only contain the merged ranges.
	            updateRanges.length = mergeIndex + 1;
	            for(let i = 0, l = updateRanges.length; i < l; i++){
	                const range = updateRanges[i];
	                gl.bufferSubData(bufferType, range.start * array.BYTES_PER_ELEMENT, array, range.start, range.count);
	            }
	            attribute.clearUpdateRanges();
	        }
	        attribute.onUploadCallback();
	    }
	    //
	    function get(attribute) {
	        if (attribute.isInterleavedBufferAttribute) attribute = attribute.data;
	        return buffers.get(attribute);
	    }
	    function remove(attribute) {
	        if (attribute.isInterleavedBufferAttribute) attribute = attribute.data;
	        const data = buffers.get(attribute);
	        if (data) {
	            gl.deleteBuffer(data.buffer);
	            buffers.delete(attribute);
	        }
	    }
	    function update(attribute, bufferType) {
	        if (attribute.isInterleavedBufferAttribute) attribute = attribute.data;
	        if (attribute.isGLBufferAttribute) {
	            const cached = buffers.get(attribute);
	            if (!cached || cached.version < attribute.version) {
	                buffers.set(attribute, {
	                    buffer: attribute.buffer,
	                    type: attribute.type,
	                    bytesPerElement: attribute.elementSize,
	                    version: attribute.version
	                });
	            }
	            return;
	        }
	        const data = buffers.get(attribute);
	        if (data === undefined) {
	            buffers.set(attribute, createBuffer(attribute, bufferType));
	        } else if (data.version < attribute.version) {
	            if (data.size !== attribute.array.byteLength) {
	                throw new Error('THREE.WebGLAttributes: The size of the buffer attribute\'s array buffer does not match the original size. Resizing buffer attributes is not supported.');
	            }
	            updateBuffer(data.buffer, attribute, bufferType);
	            data.version = attribute.version;
	        }
	    }
	    return {
	        get: get,
	        remove: remove,
	        update: update
	    };
	}
	var alphahash_fragment = "#ifdef USE_ALPHAHASH\n\tif ( diffuseColor.a < getAlphaHashThreshold( vPosition ) ) discard;\n#endif";
	var alphahash_pars_fragment = "#ifdef USE_ALPHAHASH\n\tconst float ALPHA_HASH_SCALE = 0.05;\n\tfloat hash2D( vec2 value ) {\n\t\treturn fract( 1.0e4 * sin( 17.0 * value.x + 0.1 * value.y ) * ( 0.1 + abs( sin( 13.0 * value.y + value.x ) ) ) );\n\t}\n\tfloat hash3D( vec3 value ) {\n\t\treturn hash2D( vec2( hash2D( value.xy ), value.z ) );\n\t}\n\tfloat getAlphaHashThreshold( vec3 position ) {\n\t\tfloat maxDeriv = max(\n\t\t\tlength( dFdx( position.xyz ) ),\n\t\t\tlength( dFdy( position.xyz ) )\n\t\t);\n\t\tfloat pixScale = 1.0 / ( ALPHA_HASH_SCALE * maxDeriv );\n\t\tvec2 pixScales = vec2(\n\t\t\texp2( floor( log2( pixScale ) ) ),\n\t\t\texp2( ceil( log2( pixScale ) ) )\n\t\t);\n\t\tvec2 alpha = vec2(\n\t\t\thash3D( floor( pixScales.x * position.xyz ) ),\n\t\t\thash3D( floor( pixScales.y * position.xyz ) )\n\t\t);\n\t\tfloat lerpFactor = fract( log2( pixScale ) );\n\t\tfloat x = ( 1.0 - lerpFactor ) * alpha.x + lerpFactor * alpha.y;\n\t\tfloat a = min( lerpFactor, 1.0 - lerpFactor );\n\t\tvec3 cases = vec3(\n\t\t\tx * x / ( 2.0 * a * ( 1.0 - a ) ),\n\t\t\t( x - 0.5 * a ) / ( 1.0 - a ),\n\t\t\t1.0 - ( ( 1.0 - x ) * ( 1.0 - x ) / ( 2.0 * a * ( 1.0 - a ) ) )\n\t\t);\n\t\tfloat threshold = ( x < ( 1.0 - a ) )\n\t\t\t? ( ( x < a ) ? cases.x : cases.y )\n\t\t\t: cases.z;\n\t\treturn clamp( threshold , 1.0e-6, 1.0 );\n\t}\n#endif";
	var alphamap_fragment = "#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;\n#endif";
	var alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";
	var alphatest_fragment = "#ifdef USE_ALPHATEST\n\t#ifdef ALPHA_TO_COVERAGE\n\tdiffuseColor.a = smoothstep( alphaTest, alphaTest + fwidth( diffuseColor.a ), diffuseColor.a );\n\tif ( diffuseColor.a == 0.0 ) discard;\n\t#else\n\tif ( diffuseColor.a < alphaTest ) discard;\n\t#endif\n#endif";
	var alphatest_pars_fragment = "#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif";
	var aomap_fragment = "#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_CLEARCOAT ) \n\t\tclearcoatSpecularIndirect *= ambientOcclusion;\n\t#endif\n\t#if defined( USE_SHEEN ) \n\t\tsheenSpecularIndirect *= ambientOcclusion;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometryNormal, geometryViewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif";
	var aomap_pars_fragment = "#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif";
	var batching_pars_vertex = "#ifdef USE_BATCHING\n\t#if ! defined( GL_ANGLE_multi_draw )\n\t#define gl_DrawID _gl_DrawID\n\tuniform int _gl_DrawID;\n\t#endif\n\tuniform highp sampler2D batchingTexture;\n\tuniform highp usampler2D batchingIdTexture;\n\tmat4 getBatchingMatrix( const in float i ) {\n\t\tint size = textureSize( batchingTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( batchingTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( batchingTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( batchingTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( batchingTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n\tfloat getIndirectIndex( const in int i ) {\n\t\tint size = textureSize( batchingIdTexture, 0 ).x;\n\t\tint x = i % size;\n\t\tint y = i / size;\n\t\treturn float( texelFetch( batchingIdTexture, ivec2( x, y ), 0 ).r );\n\t}\n#endif\n#ifdef USE_BATCHING_COLOR\n\tuniform sampler2D batchingColorTexture;\n\tvec3 getBatchingColor( const in float i ) {\n\t\tint size = textureSize( batchingColorTexture, 0 ).x;\n\t\tint j = int( i );\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\treturn texelFetch( batchingColorTexture, ivec2( x, y ), 0 ).rgb;\n\t}\n#endif";
	var batching_vertex = "#ifdef USE_BATCHING\n\tmat4 batchingMatrix = getBatchingMatrix( getIndirectIndex( gl_DrawID ) );\n#endif";
	var begin_vertex = "vec3 transformed = vec3( position );\n#ifdef USE_ALPHAHASH\n\tvPosition = vec3( position );\n#endif";
	var beginnormal_vertex = "vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif";
	var bsdfs = "float G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n} // validated";
	var iridescence_fragment = "#ifdef USE_IRIDESCENCE\n\tconst mat3 XYZ_TO_REC709 = mat3(\n\t\t 3.2404542, -0.9692660,  0.0556434,\n\t\t-1.5371385,  1.8760108, -0.2040259,\n\t\t-0.4985314,  0.0415560,  1.0572252\n\t);\n\tvec3 Fresnel0ToIor( vec3 fresnel0 ) {\n\t\tvec3 sqrtF0 = sqrt( fresnel0 );\n\t\treturn ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );\n\t}\n\tvec3 IorToFresnel0( vec3 transmittedIor, float incidentIor ) {\n\t\treturn pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );\n\t}\n\tfloat IorToFresnel0( float transmittedIor, float incidentIor ) {\n\t\treturn pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ));\n\t}\n\tvec3 evalSensitivity( float OPD, vec3 shift ) {\n\t\tfloat phase = 2.0 * PI * OPD * 1.0e-9;\n\t\tvec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );\n\t\tvec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );\n\t\tvec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );\n\t\tvec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - pow2( phase ) * var );\n\t\txyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * pow2( phase ) );\n\t\txyz /= 1.0685e-7;\n\t\tvec3 rgb = XYZ_TO_REC709 * xyz;\n\t\treturn rgb;\n\t}\n\tvec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {\n\t\tvec3 I;\n\t\tfloat iridescenceIOR = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );\n\t\tfloat sinTheta2Sq = pow2( outsideIOR / iridescenceIOR ) * ( 1.0 - pow2( cosTheta1 ) );\n\t\tfloat cosTheta2Sq = 1.0 - sinTheta2Sq;\n\t\tif ( cosTheta2Sq < 0.0 ) {\n\t\t\treturn vec3( 1.0 );\n\t\t}\n\t\tfloat cosTheta2 = sqrt( cosTheta2Sq );\n\t\tfloat R0 = IorToFresnel0( iridescenceIOR, outsideIOR );\n\t\tfloat R12 = F_Schlick( R0, 1.0, cosTheta1 );\n\t\tfloat T121 = 1.0 - R12;\n\t\tfloat phi12 = 0.0;\n\t\tif ( iridescenceIOR < outsideIOR ) phi12 = PI;\n\t\tfloat phi21 = PI - phi12;\n\t\tvec3 baseIOR = Fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) );\t\tvec3 R1 = IorToFresnel0( baseIOR, iridescenceIOR );\n\t\tvec3 R23 = F_Schlick( R1, 1.0, cosTheta2 );\n\t\tvec3 phi23 = vec3( 0.0 );\n\t\tif ( baseIOR[ 0 ] < iridescenceIOR ) phi23[ 0 ] = PI;\n\t\tif ( baseIOR[ 1 ] < iridescenceIOR ) phi23[ 1 ] = PI;\n\t\tif ( baseIOR[ 2 ] < iridescenceIOR ) phi23[ 2 ] = PI;\n\t\tfloat OPD = 2.0 * iridescenceIOR * thinFilmThickness * cosTheta2;\n\t\tvec3 phi = vec3( phi21 ) + phi23;\n\t\tvec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );\n\t\tvec3 r123 = sqrt( R123 );\n\t\tvec3 Rs = pow2( T121 ) * R23 / ( vec3( 1.0 ) - R123 );\n\t\tvec3 C0 = R12 + Rs;\n\t\tI = C0;\n\t\tvec3 Cm = Rs - T121;\n\t\tfor ( int m = 1; m <= 2; ++ m ) {\n\t\t\tCm *= r123;\n\t\t\tvec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );\n\t\t\tI += Cm * Sm;\n\t\t}\n\t\treturn max( I, vec3( 0.0 ) );\n\t}\n#endif";
	var bumpmap_pars_fragment = "#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vBumpMapUv );\n\t\tvec2 dSTdy = dFdy( vBumpMapUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vBumpMapUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = normalize( dFdx( surf_pos.xyz ) );\n\t\tvec3 vSigmaY = normalize( dFdy( surf_pos.xyz ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif";
	var clipping_planes_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#ifdef ALPHA_TO_COVERAGE\n\t\tfloat distanceToPlane, distanceGradient;\n\t\tfloat clipOpacity = 1.0;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n\t\t\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\n\t\t\tclipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n\t\t\tif ( clipOpacity == 0.0 ) discard;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\t\tfloat unionClipOpacity = 1.0;\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\t\tplane = clippingPlanes[ i ];\n\t\t\t\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n\t\t\t\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\n\t\t\t\tunionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\t\t\tclipOpacity *= 1.0 - unionClipOpacity;\n\t\t#endif\n\t\tdiffuseColor.a *= clipOpacity;\n\t\tif ( diffuseColor.a == 0.0 ) discard;\n\t#else\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\t\tbool clipped = true;\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\t\tplane = clippingPlanes[ i ];\n\t\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\t\t\tif ( clipped ) discard;\n\t\t#endif\n\t#endif\n#endif";
	var clipping_planes_pars_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif";
	var clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif";
	var clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif";
	var color_fragment = "#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif";
	var color_pars_fragment = "#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif";
	var color_pars_vertex = "#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )\n\tvarying vec3 vColor;\n#endif";
	var color_vertex = "#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif\n#ifdef USE_BATCHING_COLOR\n\tvec3 batchingColor = getBatchingColor( getIndirectIndex( gl_DrawID ) );\n\tvColor.xyz *= batchingColor.xyz;\n#endif";
	var common = "#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nvec3 pow2( const in vec3 x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\n#ifdef USE_ALPHAHASH\n\tvarying vec3 vPosition;\n#endif\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n} // validated";
	var cube_uv_reflection_fragment = "#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\thighp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tuv.x += filterInt * 3.0 * cubeUV_minTileSize;\n\t\tuv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\n\t\tuv.x *= CUBEUV_TEXEL_WIDTH;\n\t\tuv.y *= CUBEUV_TEXEL_HEIGHT;\n\t\t#ifdef texture2DGradEXT\n\t\t\treturn texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\n\t\t#else\n\t\t\treturn texture2D( envMap, uv ).rgb;\n\t\t#endif\n\t}\n\t#define cubeUV_r0 1.0\n\t#define cubeUV_m0 - 2.0\n\t#define cubeUV_r1 0.8\n\t#define cubeUV_m1 - 1.0\n\t#define cubeUV_r4 0.4\n\t#define cubeUV_m4 2.0\n\t#define cubeUV_r5 0.305\n\t#define cubeUV_m5 3.0\n\t#define cubeUV_r6 0.21\n\t#define cubeUV_m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= cubeUV_r1 ) {\n\t\t\tmip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\n\t\t} else if ( roughness >= cubeUV_r4 ) {\n\t\t\tmip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\n\t\t} else if ( roughness >= cubeUV_r5 ) {\n\t\t\tmip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\n\t\t} else if ( roughness >= cubeUV_r6 ) {\n\t\t\tmip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif";
	var defaultnormal_vertex = "vec3 transformedNormal = objectNormal;\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = objectTangent;\n#endif\n#ifdef USE_BATCHING\n\tmat3 bm = mat3( batchingMatrix );\n\ttransformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );\n\ttransformedNormal = bm * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = bm * transformedTangent;\n\t#endif\n#endif\n#ifdef USE_INSTANCING\n\tmat3 im = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );\n\ttransformedNormal = im * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = im * transformedTangent;\n\t#endif\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\ttransformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif";
	var displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif";
	var displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\n#endif";
	var emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE_EMISSIVE\n\t\temissiveColor = sRGBTransferEOTF( emissiveColor );\n\t#endif\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif";
	var emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif";
	var colorspace_fragment = "gl_FragColor = linearToOutputTexel( gl_FragColor );";
	var colorspace_pars_fragment = "vec4 LinearTransferOETF( in vec4 value ) {\n\treturn value;\n}\nvec4 sRGBTransferEOTF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 sRGBTransferOETF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}";
	var envmap_fragment = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, envMapRotation * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif";
	var envmap_common_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform mat3 envMapRotation;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif";
	var envmap_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif";
	var envmap_pars_vertex = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif";
	var envmap_vertex = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif";
	var fog_vertex = "#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif";
	var fog_pars_vertex = "#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif";
	var fog_fragment = "#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif";
	var fog_pars_fragment = "#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif";
	var gradientmap_pars_fragment = "#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\tvec2 fw = fwidth( coord ) * 0.5;\n\t\treturn mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\n\t#endif\n}";
	var lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif";
	var lights_lambert_fragment = "LambertMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularStrength = specularStrength;";
	var lights_lambert_pars_fragment = "varying vec3 vViewPosition;\nstruct LambertMaterial {\n\tvec3 diffuseColor;\n\tfloat specularStrength;\n};\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Lambert\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Lambert";
	var lights_pars_begin = "uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\n#if defined( USE_LIGHT_PROBES )\n\tuniform vec3 lightProbe[ 9 ];\n#endif\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif ( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif";
	var envmap_physical_pars_fragment = "#ifdef USE_ENVMAP\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\t#ifdef USE_ANISOTROPY\n\t\tvec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\n\t\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\t\tvec3 bentNormal = cross( bitangent, viewDir );\n\t\t\t\tbentNormal = normalize( cross( bentNormal, bitangent ) );\n\t\t\t\tbentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\n\t\t\t\treturn getIBLRadiance( viewDir, bentNormal, roughness );\n\t\t\t#else\n\t\t\t\treturn vec3( 0.0 );\n\t\t\t#endif\n\t\t}\n\t#endif\n#endif";
	var lights_toon_fragment = "ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;";
	var lights_toon_pars_fragment = "varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon";
	var lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;";
	var lights_phong_pars_fragment = "varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong";
	var lights_physical_fragment = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\tmaterial.ior = ior;\n\t#ifdef USE_SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULAR_COLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\n\t\t#endif\n\t\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_DISPERSION\n\tmaterial.dispersion = dispersion;\n#endif\n#ifdef USE_IRIDESCENCE\n\tmaterial.iridescence = iridescence;\n\tmaterial.iridescenceIOR = iridescenceIOR;\n\t#ifdef USE_IRIDESCENCEMAP\n\t\tmaterial.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\n\t#endif\n\t#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\t\tmaterial.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\n\t#else\n\t\tmaterial.iridescenceThickness = iridescenceThicknessMaximum;\n\t#endif\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\t#ifdef USE_ANISOTROPYMAP\n\t\tmat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\n\t\tvec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\n\t\tvec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\n\t#else\n\t\tvec2 anisotropyV = anisotropyVector;\n\t#endif\n\tmaterial.anisotropy = length( anisotropyV );\n\tif( material.anisotropy == 0.0 ) {\n\t\tanisotropyV = vec2( 1.0, 0.0 );\n\t} else {\n\t\tanisotropyV /= material.anisotropy;\n\t\tmaterial.anisotropy = saturate( material.anisotropy );\n\t}\n\tmaterial.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\n\tmaterial.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;\n\tmaterial.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;\n#endif";
	var lights_physical_pars_fragment = "struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\tfloat dispersion;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_IRIDESCENCE\n\t\tfloat iridescence;\n\t\tfloat iridescenceIOR;\n\t\tfloat iridescenceThickness;\n\t\tvec3 iridescenceFresnel;\n\t\tvec3 iridescenceF0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n\t#ifdef IOR\n\t\tfloat ior;\n\t#endif\n\t#ifdef USE_TRANSMISSION\n\t\tfloat transmission;\n\t\tfloat transmissionAlpha;\n\t\tfloat thickness;\n\t\tfloat attenuationDistance;\n\t\tvec3 attenuationColor;\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat anisotropy;\n\t\tfloat alphaT;\n\t\tvec3 anisotropyT;\n\t\tvec3 anisotropyB;\n\t#endif\n};\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\nvec3 sheenSpecularDirect = vec3( 0.0 );\nvec3 sheenSpecularIndirect = vec3(0.0 );\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\n    float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\n    float x2 = x * x;\n    float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\n    return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\n#ifdef USE_ANISOTROPY\n\tfloat V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\n\t\tfloat gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\n\t\tfloat gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\n\t\tfloat v = 0.5 / ( gv + gl );\n\t\treturn saturate(v);\n\t}\n\tfloat D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\n\t\tfloat a2 = alphaT * alphaB;\n\t\thighp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\n\t\thighp float v2 = dot( v, v );\n\t\tfloat w2 = a2 / v2;\n\t\treturn RECIPROCAL_PI * a2 * pow2 ( w2 );\n\t}\n#endif\n#ifdef USE_CLEARCOAT\n\tvec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\n\t\tvec3 f0 = material.clearcoatF0;\n\t\tfloat f90 = material.clearcoatF90;\n\t\tfloat roughness = material.clearcoatRoughness;\n\t\tfloat alpha = pow2( roughness );\n\t\tvec3 halfDir = normalize( lightDir + viewDir );\n\t\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\t\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\t\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\t\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\t\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t\treturn F * ( V * D );\n\t}\n#endif\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n\tvec3 f0 = material.specularColor;\n\tfloat f90 = material.specularF90;\n\tfloat roughness = material.roughness;\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t#ifdef USE_IRIDESCENCE\n\t\tF = mix( F, material.iridescenceFresnel, material.iridescence );\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat dotTL = dot( material.anisotropyT, lightDir );\n\t\tfloat dotTV = dot( material.anisotropyT, viewDir );\n\t\tfloat dotTH = dot( material.anisotropyT, halfDir );\n\t\tfloat dotBL = dot( material.anisotropyB, lightDir );\n\t\tfloat dotBV = dot( material.anisotropyB, viewDir );\n\t\tfloat dotBH = dot( material.anisotropyB, halfDir );\n\t\tfloat V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\n\t\tfloat D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\n\t#else\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t#endif\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\n#ifdef USE_IRIDESCENCE\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#else\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#endif\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\t#ifdef USE_IRIDESCENCE\n\t\tvec3 Fr = mix( specularColor, iridescenceF0, iridescence );\n\t#else\n\t\tvec3 Fr = specularColor;\n\t#endif\n\tvec3 FssEss = Fr * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometryNormal;\n\t\tvec3 viewDir = geometryViewDir;\n\t\tvec3 position = geometryPosition;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\t#ifdef USE_IRIDESCENCE\n\t\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );\n\t#else\n\t\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\t#endif\n\tvec3 totalScattering = singleScattering + multiScattering;\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}";
	var lights_fragment_begin = "\nvec3 geometryPosition = - vViewPosition;\nvec3 geometryNormal = normal;\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\nvec3 geometryClearcoatNormal = vec3( 0.0 );\n#ifdef USE_CLEARCOAT\n\tgeometryClearcoatNormal = clearcoatNormal;\n#endif\n#ifdef USE_IRIDESCENCE\n\tfloat dotNVi = saturate( dot( normal, geometryViewDir ) );\n\tif ( material.iridescenceThickness == 0.0 ) {\n\t\tmaterial.iridescence = 0.0;\n\t} else {\n\t\tmaterial.iridescence = saturate( material.iridescence );\n\t}\n\tif ( material.iridescence > 0.0 ) {\n\t\tmaterial.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\n\t\tmaterial.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\n\t}\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometryPosition, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\tvec4 spotColor;\n\tvec3 spotLightCoord;\n\tbool inSpotLightMap;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometryPosition, directLight );\n\t\t#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\n\t\t#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\n\t\t#else\n\t\t#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#endif\n\t\t#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\n\t\t\tspotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\n\t\t\tinSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\n\t\t\tspotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\n\t\t\tdirectLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\n\t\t#endif\n\t\t#undef SPOT_LIGHT_MAP_INDEX\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#if defined( USE_LIGHT_PROBES )\n\t\tirradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif";
	var lights_fragment_maps = "#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometryNormal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\t#ifdef USE_ANISOTROPY\n\t\tradiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\n\t#else\n\t\tradiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif";
	var lights_fragment_end = "#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif";
	var logdepthbuf_fragment = "#if defined( USE_LOGDEPTHBUF )\n\tgl_FragDepth = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif";
	var logdepthbuf_pars_fragment = "#if defined( USE_LOGDEPTHBUF )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif";
	var logdepthbuf_pars_vertex = "#ifdef USE_LOGDEPTHBUF\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif";
	var logdepthbuf_vertex = "#ifdef USE_LOGDEPTHBUF\n\tvFragDepth = 1.0 + gl_Position.w;\n\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n#endif";
	var map_fragment = "#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = sRGBTransferEOTF( sampledDiffuseColor );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif";
	var map_pars_fragment = "#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif";
	var map_particle_fragment = "#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t#if defined( USE_POINTS_UV )\n\t\tvec2 uv = vUv;\n\t#else\n\t\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif";
	var map_particle_pars_fragment = "#if defined( USE_POINTS_UV )\n\tvarying vec2 vUv;\n#else\n\t#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t\tuniform mat3 uvTransform;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";
	var metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif";
	var metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif";
	var morphinstance_vertex = "#ifdef USE_INSTANCING_MORPH\n\tfloat morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\tfloat morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tmorphTargetInfluences[i] =  texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;\n\t}\n#endif";
	var morphcolor_vertex = "#if defined( USE_MORPHCOLORS )\n\tvColor *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t#if defined( USE_COLOR_ALPHA )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\n\t\t#elif defined( USE_COLOR )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\n\t\t#endif\n\t}\n#endif";
	var morphnormal_vertex = "#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\n\t}\n#endif";
	var morphtarget_pars_vertex = "#ifdef USE_MORPHTARGETS\n\t#ifndef USE_INSTANCING_MORPH\n\t\tuniform float morphTargetBaseInfluence;\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t#endif\n\tuniform sampler2DArray morphTargetsTexture;\n\tuniform ivec2 morphTargetsTextureSize;\n\tvec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\n\t\tint texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\n\t\tint y = texelIndex / morphTargetsTextureSize.x;\n\t\tint x = texelIndex - y * morphTargetsTextureSize.x;\n\t\tivec3 morphUV = ivec3( x, y, morphTargetIndex );\n\t\treturn texelFetch( morphTargetsTexture, morphUV, 0 );\n\t}\n#endif";
	var morphtarget_vertex = "#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\n\t}\n#endif";
	var normal_fragment_begin = "float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = dFdx( vViewPosition );\n\tvec3 fdy = dFdy( vViewPosition );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal *= faceDirection;\n\t#endif\n#endif\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn = getTangentFrame( - vViewPosition, normal,\n\t\t#if defined( USE_NORMALMAP )\n\t\t\tvNormalMapUv\n\t\t#elif defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tvClearcoatNormalMapUv\n\t\t#else\n\t\t\tvUv\n\t\t#endif\n\t\t);\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn[0] *= faceDirection;\n\t\ttbn[1] *= faceDirection;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn2[0] *= faceDirection;\n\t\ttbn2[1] *= faceDirection;\n\t#endif\n#endif\nvec3 nonPerturbedNormal = normal;";
	var normal_fragment_maps = "#ifdef USE_NORMALMAP_OBJECTSPACE\n\tnormal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\n\tvec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\tnormal = normalize( tbn * mapN );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif";
	var normal_pars_fragment = "#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif";
	var normal_pars_vertex = "#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif";
	var normal_vertex = "#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif";
	var normalmap_pars_fragment = "#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef USE_NORMALMAP_OBJECTSPACE\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\n\tmat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\n\t\tvec3 q0 = dFdx( eye_pos.xyz );\n\t\tvec3 q1 = dFdy( eye_pos.xyz );\n\t\tvec2 st0 = dFdx( uv.st );\n\t\tvec2 st1 = dFdy( uv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\n\t\treturn mat3( T * scale, B * scale, N );\n\t}\n#endif";
	var clearcoat_normal_fragment_begin = "#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = nonPerturbedNormal;\n#endif";
	var clearcoat_normal_fragment_maps = "#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\tclearcoatNormal = normalize( tbn2 * clearcoatMapN );\n#endif";
	var clearcoat_pars_fragment = "#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif";
	var iridescence_pars_fragment = "#ifdef USE_IRIDESCENCEMAP\n\tuniform sampler2D iridescenceMap;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform sampler2D iridescenceThicknessMap;\n#endif";
	var opaque_fragment = "#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= material.transmissionAlpha;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );";
	var packing = "vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;const float ShiftRight8 = 1. / 256.;\nconst float Inv255 = 1. / 255.;\nconst vec4 PackFactors = vec4( 1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0 );\nconst vec2 UnpackFactors2 = vec2( UnpackDownscale, 1.0 / PackFactors.g );\nconst vec3 UnpackFactors3 = vec3( UnpackDownscale / PackFactors.rg, 1.0 / PackFactors.b );\nconst vec4 UnpackFactors4 = vec4( UnpackDownscale / PackFactors.rgb, 1.0 / PackFactors.a );\nvec4 packDepthToRGBA( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec4( 0., 0., 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec4( 1., 1., 1., 1. );\n\tfloat vuf;\n\tfloat af = modf( v * PackFactors.a, vuf );\n\tfloat bf = modf( vuf * ShiftRight8, vuf );\n\tfloat gf = modf( vuf * ShiftRight8, vuf );\n\treturn vec4( vuf * Inv255, gf * PackUpscale, bf * PackUpscale, af );\n}\nvec3 packDepthToRGB( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec3( 0., 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec3( 1., 1., 1. );\n\tfloat vuf;\n\tfloat bf = modf( v * PackFactors.b, vuf );\n\tfloat gf = modf( vuf * ShiftRight8, vuf );\n\treturn vec3( vuf * Inv255, gf * PackUpscale, bf );\n}\nvec2 packDepthToRG( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec2( 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec2( 1., 1. );\n\tfloat vuf;\n\tfloat gf = modf( v * 256., vuf );\n\treturn vec2( vuf * Inv255, gf );\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors4 );\n}\nfloat unpackRGBToDepth( const in vec3 v ) {\n\treturn dot( v, UnpackFactors3 );\n}\nfloat unpackRGToDepth( const in vec2 v ) {\n\treturn v.r * UnpackFactors2.r + v.g * UnpackFactors2.g;\n}\nvec4 pack2HalfToRGBA( const in vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( const in vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn depth * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * depth - far );\n}";
	var premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif";
	var project_vertex = "vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_BATCHING\n\tmvPosition = batchingMatrix * mvPosition;\n#endif\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;";
	var dithering_fragment = "#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif";
	var dithering_pars_fragment = "#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif";
	var roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\n\troughnessFactor *= texelRoughness.g;\n#endif";
	var roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif";
	var shadowmap_pars_fragment = "#if NUM_SPOT_LIGHT_COORDS > 0\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#if NUM_SPOT_LIGHT_MAPS > 0\n\tuniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tfloat shadow = 1.0;\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\t\n\t\tfloat lightToPositionLength = length( lightToPosition );\n\t\tif ( lightToPositionLength - shadowCameraFar <= 0.0 && lightToPositionLength - shadowCameraNear >= 0.0 ) {\n\t\t\tfloat dp = ( lightToPositionLength - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\t\tdp += shadowBias;\n\t\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\t\tshadow = (\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t\t) * ( 1.0 / 9.0 );\n\t\t\t#else\n\t\t\t\tshadow = texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t\t#endif\n\t\t}\n\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t}\n#endif";
	var shadowmap_pars_vertex = "#if NUM_SPOT_LIGHT_COORDS > 0\n\tuniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif";
	var shadowmap_vertex = "#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\n\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\tvec4 shadowWorldPosition;\n#endif\n#if defined( USE_SHADOWMAP )\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if NUM_SPOT_LIGHT_COORDS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition;\n\t\t#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t\tshadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\n\t\t#endif\n\t\tvSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n#endif";
	var shadowmask_pars_fragment = "float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowIntensity, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowIntensity, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowIntensity, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}";
	var skinbase_vertex = "#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";
	var skinning_pars_vertex = "#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\tuniform highp sampler2D boneTexture;\n\tmat4 getBoneMatrix( const in float i ) {\n\t\tint size = textureSize( boneTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n#endif";
	var skinning_vertex = "#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif";
	var skinnormal_vertex = "#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif";
	var specularmap_fragment = "float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif";
	var specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif";
	var tonemapping_fragment = "#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif";
	var tonemapping_pars_fragment = "#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn saturate( toneMappingExposure * color );\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 CineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\n\tvec3( 1.6605, - 0.1246, - 0.0182 ),\n\tvec3( - 0.5876, 1.1329, - 0.1006 ),\n\tvec3( - 0.0728, - 0.0083, 1.1187 )\n);\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\n\tvec3( 0.6274, 0.0691, 0.0164 ),\n\tvec3( 0.3293, 0.9195, 0.0880 ),\n\tvec3( 0.0433, 0.0113, 0.8956 )\n);\nvec3 agxDefaultContrastApprox( vec3 x ) {\n\tvec3 x2 = x * x;\n\tvec3 x4 = x2 * x2;\n\treturn + 15.5 * x4 * x2\n\t\t- 40.14 * x4 * x\n\t\t+ 31.96 * x4\n\t\t- 6.868 * x2 * x\n\t\t+ 0.4298 * x2\n\t\t+ 0.1191 * x\n\t\t- 0.00232;\n}\nvec3 AgXToneMapping( vec3 color ) {\n\tconst mat3 AgXInsetMatrix = mat3(\n\t\tvec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),\n\t\tvec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),\n\t\tvec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )\n\t);\n\tconst mat3 AgXOutsetMatrix = mat3(\n\t\tvec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),\n\t\tvec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),\n\t\tvec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )\n\t);\n\tconst float AgxMinEv = - 12.47393;\tconst float AgxMaxEv = 4.026069;\n\tcolor *= toneMappingExposure;\n\tcolor = LINEAR_SRGB_TO_LINEAR_REC2020 * color;\n\tcolor = AgXInsetMatrix * color;\n\tcolor = max( color, 1e-10 );\tcolor = log2( color );\n\tcolor = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );\n\tcolor = clamp( color, 0.0, 1.0 );\n\tcolor = agxDefaultContrastApprox( color );\n\tcolor = AgXOutsetMatrix * color;\n\tcolor = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );\n\tcolor = LINEAR_REC2020_TO_LINEAR_SRGB * color;\n\tcolor = clamp( color, 0.0, 1.0 );\n\treturn color;\n}\nvec3 NeutralToneMapping( vec3 color ) {\n\tconst float StartCompression = 0.8 - 0.04;\n\tconst float Desaturation = 0.15;\n\tcolor *= toneMappingExposure;\n\tfloat x = min( color.r, min( color.g, color.b ) );\n\tfloat offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n\tcolor -= offset;\n\tfloat peak = max( color.r, max( color.g, color.b ) );\n\tif ( peak < StartCompression ) return color;\n\tfloat d = 1. - StartCompression;\n\tfloat newPeak = 1. - d * d / ( peak + d - StartCompression );\n\tcolor *= newPeak / peak;\n\tfloat g = 1. - 1. / ( Desaturation * ( peak - newPeak ) + 1. );\n\treturn mix( color, vec3( newPeak ), g );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }";
	var transmission_fragment = "#ifdef USE_TRANSMISSION\n\tmaterial.transmission = transmission;\n\tmaterial.transmissionAlpha = 1.0;\n\tmaterial.thickness = thickness;\n\tmaterial.attenuationDistance = attenuationDistance;\n\tmaterial.attenuationColor = attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tmaterial.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tmaterial.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmitted = getIBLVolumeRefraction(\n\t\tn, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, material.dispersion, material.ior, material.thickness,\n\t\tmaterial.attenuationColor, material.attenuationDistance );\n\tmaterial.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\n\ttotalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\n#endif";
	var transmission_pars_fragment = "#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tfloat w0( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\n\t}\n\tfloat w1( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a *  a * ( 3.0 * a - 6.0 ) + 4.0 );\n\t}\n\tfloat w2( float a ){\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\n\t}\n\tfloat w3( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * a );\n\t}\n\tfloat g0( float a ) {\n\t\treturn w0( a ) + w1( a );\n\t}\n\tfloat g1( float a ) {\n\t\treturn w2( a ) + w3( a );\n\t}\n\tfloat h0( float a ) {\n\t\treturn - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\n\t}\n\tfloat h1( float a ) {\n\t\treturn 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\n\t}\n\tvec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\n\t\tuv = uv * texelSize.zw + 0.5;\n\t\tvec2 iuv = floor( uv );\n\t\tvec2 fuv = fract( uv );\n\t\tfloat g0x = g0( fuv.x );\n\t\tfloat g1x = g1( fuv.x );\n\t\tfloat h0x = h0( fuv.x );\n\t\tfloat h1x = h1( fuv.x );\n\t\tfloat h0y = h0( fuv.y );\n\t\tfloat h1y = h1( fuv.y );\n\t\tvec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\treturn g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\n\t\t\tg1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\n\t}\n\tvec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\n\t\tvec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\n\t\tvec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\n\t\tvec2 fLodSizeInv = 1.0 / fLodSize;\n\t\tvec2 cLodSizeInv = 1.0 / cLodSize;\n\t\tvec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\n\t\tvec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\n\t\treturn mix( fSample, cSample, fract( lod ) );\n\t}\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\treturn textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\n\t}\n\tvec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( isinf( attenuationDistance ) ) {\n\t\t\treturn vec3( 1.0 );\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float dispersion, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec4 transmittedLight;\n\t\tvec3 transmittance;\n\t\t#ifdef USE_DISPERSION\n\t\t\tfloat halfSpread = ( ior - 1.0 ) * 0.025 * dispersion;\n\t\t\tvec3 iors = vec3( ior - halfSpread, ior, ior + halfSpread );\n\t\t\tfor ( int i = 0; i < 3; i ++ ) {\n\t\t\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, iors[ i ], modelMatrix );\n\t\t\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\t\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\t\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\t\t\trefractionCoords += 1.0;\n\t\t\t\trefractionCoords /= 2.0;\n\t\t\t\tvec4 transmissionSample = getTransmissionSample( refractionCoords, roughness, iors[ i ] );\n\t\t\t\ttransmittedLight[ i ] = transmissionSample[ i ];\n\t\t\t\ttransmittedLight.a += transmissionSample.a;\n\t\t\t\ttransmittance[ i ] = diffuseColor[ i ] * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance )[ i ];\n\t\t\t}\n\t\t\ttransmittedLight.a /= 3.0;\n\t\t#else\n\t\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\t\trefractionCoords += 1.0;\n\t\t\trefractionCoords /= 2.0;\n\t\t\ttransmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\t\ttransmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\t#endif\n\t\tvec3 attenuatedColor = transmittance * transmittedLight.rgb;\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\tfloat transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\n\t}\n#endif";
	var uv_pars_fragment = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif";
	var uv_pars_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tuniform mat3 mapTransform;\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform mat3 alphaMapTransform;\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tuniform mat3 lightMapTransform;\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tuniform mat3 aoMapTransform;\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tuniform mat3 bumpMapTransform;\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tuniform mat3 normalMapTransform;\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tuniform mat3 displacementMapTransform;\n\tvarying vec2 vDisplacementMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tuniform mat3 emissiveMapTransform;\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tuniform mat3 metalnessMapTransform;\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tuniform mat3 roughnessMapTransform;\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tuniform mat3 anisotropyMapTransform;\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tuniform mat3 clearcoatMapTransform;\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform mat3 clearcoatNormalMapTransform;\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform mat3 clearcoatRoughnessMapTransform;\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tuniform mat3 sheenColorMapTransform;\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tuniform mat3 sheenRoughnessMapTransform;\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tuniform mat3 iridescenceMapTransform;\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform mat3 iridescenceThicknessMapTransform;\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tuniform mat3 specularMapTransform;\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tuniform mat3 specularColorMapTransform;\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tuniform mat3 specularIntensityMapTransform;\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif";
	var uv_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvUv = vec3( uv, 1 ).xy;\n#endif\n#ifdef USE_MAP\n\tvMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ALPHAMAP\n\tvAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_LIGHTMAP\n\tvLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_AOMAP\n\tvAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_BUMPMAP\n\tvBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_NORMALMAP\n\tvNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tvDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_METALNESSMAP\n\tvMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULARMAP\n\tvSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tvTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_THICKNESSMAP\n\tvThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\n#endif";
	var worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_BATCHING\n\t\tworldPosition = batchingMatrix * worldPosition;\n\t#endif\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif";
	const vertex$h = "varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}";
	const fragment$h = "uniform sampler2D t2D;\nuniform float backgroundIntensity;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\ttexColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
	const vertex$g = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";
	const fragment$g = "#ifdef ENVMAP_TYPE_CUBE\n\tuniform samplerCube envMap;\n#elif defined( ENVMAP_TYPE_CUBE_UV )\n\tuniform sampler2D envMap;\n#endif\nuniform float flipEnvMap;\nuniform float backgroundBlurriness;\nuniform float backgroundIntensity;\nuniform mat3 backgroundRotation;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 texColor = textureCube( envMap, backgroundRotation * vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );\n\t#else\n\t\tvec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
	const vertex$f = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";
	const fragment$f = "uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor = texColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
	const vertex$e = "#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <skinbase_vertex>\n\t#include <morphinstance_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}";
	const fragment$e = "#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <clipping_planes_fragment>\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#elif DEPTH_PACKING == 3202\n\t\tgl_FragColor = vec4( packDepthToRGB( fragCoordZ ), 1.0 );\n\t#elif DEPTH_PACKING == 3203\n\t\tgl_FragColor = vec4( packDepthToRG( fragCoordZ ), 0.0, 1.0 );\n\t#endif\n}";
	const vertex$d = "#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <skinbase_vertex>\n\t#include <morphinstance_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}";
	const fragment$d = "#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <clipping_planes_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}";
	const vertex$c = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}";
	const fragment$c = "uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
	const vertex$b = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$b = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";
	const vertex$a = "#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$a = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
	const vertex$9 = "#define LAMBERT\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$9 = "#define LAMBERT\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_lambert_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_lambert_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
	const vertex$8 = "#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}";
	const fragment$8 = "#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
	const vertex$7 = "#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}";
	const fragment$7 = "#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( 0.0, 0.0, 0.0, opacity );\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), diffuseColor.a );\n\t#ifdef OPAQUE\n\t\tgl_FragColor.a = 1.0;\n\t#endif\n}";
	const vertex$6 = "#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$6 = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
	const vertex$5 = "#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}";
	const fragment$5 = "#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_DISPERSION\n\tuniform float dispersion;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\tuniform vec2 anisotropyVector;\n\t#ifdef USE_ANISOTROPYMAP\n\t\tuniform sampler2D anisotropyMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <iridescence_fragment>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <iridescence_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n\t#endif\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
	const vertex$4 = "#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$4 = "#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
	const vertex$3 = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n#ifdef USE_POINTS_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif\nvoid main() {\n\t#ifdef USE_POINTS_UV\n\t\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\t#endif\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$3 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";
	const vertex$2 = "#include <common>\n#include <batching_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$2 = "uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <logdepthbuf_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\t#include <logdepthbuf_fragment>\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
	const vertex$1 = "uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix[ 3 ];\n\tvec2 scale = vec2( length( modelMatrix[ 0 ].xyz ), length( modelMatrix[ 1 ].xyz ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
	const fragment$1 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
	const ShaderChunk = {
	    alphahash_fragment: alphahash_fragment,
	    alphahash_pars_fragment: alphahash_pars_fragment,
	    alphamap_fragment: alphamap_fragment,
	    alphamap_pars_fragment: alphamap_pars_fragment,
	    alphatest_fragment: alphatest_fragment,
	    alphatest_pars_fragment: alphatest_pars_fragment,
	    aomap_fragment: aomap_fragment,
	    aomap_pars_fragment: aomap_pars_fragment,
	    batching_pars_vertex: batching_pars_vertex,
	    batching_vertex: batching_vertex,
	    begin_vertex: begin_vertex,
	    beginnormal_vertex: beginnormal_vertex,
	    bsdfs: bsdfs,
	    iridescence_fragment: iridescence_fragment,
	    bumpmap_pars_fragment: bumpmap_pars_fragment,
	    clipping_planes_fragment: clipping_planes_fragment,
	    clipping_planes_pars_fragment: clipping_planes_pars_fragment,
	    clipping_planes_pars_vertex: clipping_planes_pars_vertex,
	    clipping_planes_vertex: clipping_planes_vertex,
	    color_fragment: color_fragment,
	    color_pars_fragment: color_pars_fragment,
	    color_pars_vertex: color_pars_vertex,
	    color_vertex: color_vertex,
	    common: common,
	    cube_uv_reflection_fragment: cube_uv_reflection_fragment,
	    defaultnormal_vertex: defaultnormal_vertex,
	    displacementmap_pars_vertex: displacementmap_pars_vertex,
	    displacementmap_vertex: displacementmap_vertex,
	    emissivemap_fragment: emissivemap_fragment,
	    emissivemap_pars_fragment: emissivemap_pars_fragment,
	    colorspace_fragment: colorspace_fragment,
	    colorspace_pars_fragment: colorspace_pars_fragment,
	    envmap_fragment: envmap_fragment,
	    envmap_common_pars_fragment: envmap_common_pars_fragment,
	    envmap_pars_fragment: envmap_pars_fragment,
	    envmap_pars_vertex: envmap_pars_vertex,
	    envmap_physical_pars_fragment: envmap_physical_pars_fragment,
	    envmap_vertex: envmap_vertex,
	    fog_vertex: fog_vertex,
	    fog_pars_vertex: fog_pars_vertex,
	    fog_fragment: fog_fragment,
	    fog_pars_fragment: fog_pars_fragment,
	    gradientmap_pars_fragment: gradientmap_pars_fragment,
	    lightmap_pars_fragment: lightmap_pars_fragment,
	    lights_lambert_fragment: lights_lambert_fragment,
	    lights_lambert_pars_fragment: lights_lambert_pars_fragment,
	    lights_pars_begin: lights_pars_begin,
	    lights_toon_fragment: lights_toon_fragment,
	    lights_toon_pars_fragment: lights_toon_pars_fragment,
	    lights_phong_fragment: lights_phong_fragment,
	    lights_phong_pars_fragment: lights_phong_pars_fragment,
	    lights_physical_fragment: lights_physical_fragment,
	    lights_physical_pars_fragment: lights_physical_pars_fragment,
	    lights_fragment_begin: lights_fragment_begin,
	    lights_fragment_maps: lights_fragment_maps,
	    lights_fragment_end: lights_fragment_end,
	    logdepthbuf_fragment: logdepthbuf_fragment,
	    logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
	    logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
	    logdepthbuf_vertex: logdepthbuf_vertex,
	    map_fragment: map_fragment,
	    map_pars_fragment: map_pars_fragment,
	    map_particle_fragment: map_particle_fragment,
	    map_particle_pars_fragment: map_particle_pars_fragment,
	    metalnessmap_fragment: metalnessmap_fragment,
	    metalnessmap_pars_fragment: metalnessmap_pars_fragment,
	    morphinstance_vertex: morphinstance_vertex,
	    morphcolor_vertex: morphcolor_vertex,
	    morphnormal_vertex: morphnormal_vertex,
	    morphtarget_pars_vertex: morphtarget_pars_vertex,
	    morphtarget_vertex: morphtarget_vertex,
	    normal_fragment_begin: normal_fragment_begin,
	    normal_fragment_maps: normal_fragment_maps,
	    normal_pars_fragment: normal_pars_fragment,
	    normal_pars_vertex: normal_pars_vertex,
	    normal_vertex: normal_vertex,
	    normalmap_pars_fragment: normalmap_pars_fragment,
	    clearcoat_normal_fragment_begin: clearcoat_normal_fragment_begin,
	    clearcoat_normal_fragment_maps: clearcoat_normal_fragment_maps,
	    clearcoat_pars_fragment: clearcoat_pars_fragment,
	    iridescence_pars_fragment: iridescence_pars_fragment,
	    opaque_fragment: opaque_fragment,
	    packing: packing,
	    premultiplied_alpha_fragment: premultiplied_alpha_fragment,
	    project_vertex: project_vertex,
	    dithering_fragment: dithering_fragment,
	    dithering_pars_fragment: dithering_pars_fragment,
	    roughnessmap_fragment: roughnessmap_fragment,
	    roughnessmap_pars_fragment: roughnessmap_pars_fragment,
	    shadowmap_pars_fragment: shadowmap_pars_fragment,
	    shadowmap_pars_vertex: shadowmap_pars_vertex,
	    shadowmap_vertex: shadowmap_vertex,
	    shadowmask_pars_fragment: shadowmask_pars_fragment,
	    skinbase_vertex: skinbase_vertex,
	    skinning_pars_vertex: skinning_pars_vertex,
	    skinning_vertex: skinning_vertex,
	    skinnormal_vertex: skinnormal_vertex,
	    specularmap_fragment: specularmap_fragment,
	    specularmap_pars_fragment: specularmap_pars_fragment,
	    tonemapping_fragment: tonemapping_fragment,
	    tonemapping_pars_fragment: tonemapping_pars_fragment,
	    transmission_fragment: transmission_fragment,
	    transmission_pars_fragment: transmission_pars_fragment,
	    uv_pars_fragment: uv_pars_fragment,
	    uv_pars_vertex: uv_pars_vertex,
	    uv_vertex: uv_vertex,
	    worldpos_vertex: worldpos_vertex,
	    background_vert: vertex$h,
	    background_frag: fragment$h,
	    backgroundCube_vert: vertex$g,
	    backgroundCube_frag: fragment$g,
	    cube_vert: vertex$f,
	    cube_frag: fragment$f,
	    depth_vert: vertex$e,
	    depth_frag: fragment$e,
	    distanceRGBA_vert: vertex$d,
	    distanceRGBA_frag: fragment$d,
	    equirect_vert: vertex$c,
	    equirect_frag: fragment$c,
	    linedashed_vert: vertex$b,
	    linedashed_frag: fragment$b,
	    meshbasic_vert: vertex$a,
	    meshbasic_frag: fragment$a,
	    meshlambert_vert: vertex$9,
	    meshlambert_frag: fragment$9,
	    meshmatcap_vert: vertex$8,
	    meshmatcap_frag: fragment$8,
	    meshnormal_vert: vertex$7,
	    meshnormal_frag: fragment$7,
	    meshphong_vert: vertex$6,
	    meshphong_frag: fragment$6,
	    meshphysical_vert: vertex$5,
	    meshphysical_frag: fragment$5,
	    meshtoon_vert: vertex$4,
	    meshtoon_frag: fragment$4,
	    points_vert: vertex$3,
	    points_frag: fragment$3,
	    shadow_vert: vertex$2,
	    shadow_frag: fragment$2,
	    sprite_vert: vertex$1,
	    sprite_frag: fragment$1
	};
	/**
	 * Uniforms library for shared webgl shaders
	 */ const UniformsLib = {
	    common: {
	        diffuse: {
	            value: /*@__PURE__*/ new Color(0xffffff)
	        },
	        opacity: {
	            value: 1.0
	        },
	        map: {
	            value: null
	        },
	        mapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        alphaMap: {
	            value: null
	        },
	        alphaMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        alphaTest: {
	            value: 0
	        }
	    },
	    specularmap: {
	        specularMap: {
	            value: null
	        },
	        specularMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    envmap: {
	        envMap: {
	            value: null
	        },
	        envMapRotation: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        flipEnvMap: {
	            value: -1
	        },
	        reflectivity: {
	            value: 1.0
	        },
	        ior: {
	            value: 1.5
	        },
	        refractionRatio: {
	            value: 0.98
	        }
	    },
	    aomap: {
	        aoMap: {
	            value: null
	        },
	        aoMapIntensity: {
	            value: 1
	        },
	        aoMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    lightmap: {
	        lightMap: {
	            value: null
	        },
	        lightMapIntensity: {
	            value: 1
	        },
	        lightMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    bumpmap: {
	        bumpMap: {
	            value: null
	        },
	        bumpMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        bumpScale: {
	            value: 1
	        }
	    },
	    normalmap: {
	        normalMap: {
	            value: null
	        },
	        normalMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        normalScale: {
	            value: /*@__PURE__*/ new Vector2(1, 1)
	        }
	    },
	    displacementmap: {
	        displacementMap: {
	            value: null
	        },
	        displacementMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        displacementScale: {
	            value: 1
	        },
	        displacementBias: {
	            value: 0
	        }
	    },
	    emissivemap: {
	        emissiveMap: {
	            value: null
	        },
	        emissiveMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    metalnessmap: {
	        metalnessMap: {
	            value: null
	        },
	        metalnessMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    roughnessmap: {
	        roughnessMap: {
	            value: null
	        },
	        roughnessMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    gradientmap: {
	        gradientMap: {
	            value: null
	        }
	    },
	    fog: {
	        fogDensity: {
	            value: 0.00025
	        },
	        fogNear: {
	            value: 1
	        },
	        fogFar: {
	            value: 2000
	        },
	        fogColor: {
	            value: /*@__PURE__*/ new Color(0xffffff)
	        }
	    },
	    lights: {
	        ambientLightColor: {
	            value: []
	        },
	        lightProbe: {
	            value: []
	        },
	        directionalLights: {
	            value: [],
	            properties: {
	                direction: {},
	                color: {}
	            }
	        },
	        directionalLightShadows: {
	            value: [],
	            properties: {
	                shadowIntensity: 1,
	                shadowBias: {},
	                shadowNormalBias: {},
	                shadowRadius: {},
	                shadowMapSize: {}
	            }
	        },
	        directionalShadowMap: {
	            value: []
	        },
	        directionalShadowMatrix: {
	            value: []
	        },
	        spotLights: {
	            value: [],
	            properties: {
	                color: {},
	                position: {},
	                direction: {},
	                distance: {},
	                coneCos: {},
	                penumbraCos: {},
	                decay: {}
	            }
	        },
	        spotLightShadows: {
	            value: [],
	            properties: {
	                shadowIntensity: 1,
	                shadowBias: {},
	                shadowNormalBias: {},
	                shadowRadius: {},
	                shadowMapSize: {}
	            }
	        },
	        spotLightMap: {
	            value: []
	        },
	        spotShadowMap: {
	            value: []
	        },
	        spotLightMatrix: {
	            value: []
	        },
	        pointLights: {
	            value: [],
	            properties: {
	                color: {},
	                position: {},
	                decay: {},
	                distance: {}
	            }
	        },
	        pointLightShadows: {
	            value: [],
	            properties: {
	                shadowIntensity: 1,
	                shadowBias: {},
	                shadowNormalBias: {},
	                shadowRadius: {},
	                shadowMapSize: {},
	                shadowCameraNear: {},
	                shadowCameraFar: {}
	            }
	        },
	        pointShadowMap: {
	            value: []
	        },
	        pointShadowMatrix: {
	            value: []
	        },
	        hemisphereLights: {
	            value: [],
	            properties: {
	                direction: {},
	                skyColor: {},
	                groundColor: {}
	            }
	        },
	        // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
	        rectAreaLights: {
	            value: [],
	            properties: {
	                color: {},
	                position: {},
	                width: {},
	                height: {}
	            }
	        },
	        ltc_1: {
	            value: null
	        },
	        ltc_2: {
	            value: null
	        }
	    },
	    points: {
	        diffuse: {
	            value: /*@__PURE__*/ new Color(0xffffff)
	        },
	        opacity: {
	            value: 1.0
	        },
	        size: {
	            value: 1.0
	        },
	        scale: {
	            value: 1.0
	        },
	        map: {
	            value: null
	        },
	        alphaMap: {
	            value: null
	        },
	        alphaMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        alphaTest: {
	            value: 0
	        },
	        uvTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        }
	    },
	    sprite: {
	        diffuse: {
	            value: /*@__PURE__*/ new Color(0xffffff)
	        },
	        opacity: {
	            value: 1.0
	        },
	        center: {
	            value: /*@__PURE__*/ new Vector2(0.5, 0.5)
	        },
	        rotation: {
	            value: 0.0
	        },
	        map: {
	            value: null
	        },
	        mapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        alphaMap: {
	            value: null
	        },
	        alphaMapTransform: {
	            value: /*@__PURE__*/ new Matrix3()
	        },
	        alphaTest: {
	            value: 0
	        }
	    }
	};
	const ShaderLib = {
	    basic: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.specularmap,
	            UniformsLib.envmap,
	            UniformsLib.aomap,
	            UniformsLib.lightmap,
	            UniformsLib.fog
	        ]),
	        vertexShader: ShaderChunk.meshbasic_vert,
	        fragmentShader: ShaderChunk.meshbasic_frag
	    },
	    lambert: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.specularmap,
	            UniformsLib.envmap,
	            UniformsLib.aomap,
	            UniformsLib.lightmap,
	            UniformsLib.emissivemap,
	            UniformsLib.bumpmap,
	            UniformsLib.normalmap,
	            UniformsLib.displacementmap,
	            UniformsLib.fog,
	            UniformsLib.lights,
	            {
	                emissive: {
	                    value: /*@__PURE__*/ new Color(0x000000)
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.meshlambert_vert,
	        fragmentShader: ShaderChunk.meshlambert_frag
	    },
	    phong: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.specularmap,
	            UniformsLib.envmap,
	            UniformsLib.aomap,
	            UniformsLib.lightmap,
	            UniformsLib.emissivemap,
	            UniformsLib.bumpmap,
	            UniformsLib.normalmap,
	            UniformsLib.displacementmap,
	            UniformsLib.fog,
	            UniformsLib.lights,
	            {
	                emissive: {
	                    value: /*@__PURE__*/ new Color(0x000000)
	                },
	                specular: {
	                    value: /*@__PURE__*/ new Color(0x111111)
	                },
	                shininess: {
	                    value: 30
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.meshphong_vert,
	        fragmentShader: ShaderChunk.meshphong_frag
	    },
	    standard: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.envmap,
	            UniformsLib.aomap,
	            UniformsLib.lightmap,
	            UniformsLib.emissivemap,
	            UniformsLib.bumpmap,
	            UniformsLib.normalmap,
	            UniformsLib.displacementmap,
	            UniformsLib.roughnessmap,
	            UniformsLib.metalnessmap,
	            UniformsLib.fog,
	            UniformsLib.lights,
	            {
	                emissive: {
	                    value: /*@__PURE__*/ new Color(0x000000)
	                },
	                roughness: {
	                    value: 1.0
	                },
	                metalness: {
	                    value: 0.0
	                },
	                envMapIntensity: {
	                    value: 1
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.meshphysical_vert,
	        fragmentShader: ShaderChunk.meshphysical_frag
	    },
	    toon: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.aomap,
	            UniformsLib.lightmap,
	            UniformsLib.emissivemap,
	            UniformsLib.bumpmap,
	            UniformsLib.normalmap,
	            UniformsLib.displacementmap,
	            UniformsLib.gradientmap,
	            UniformsLib.fog,
	            UniformsLib.lights,
	            {
	                emissive: {
	                    value: /*@__PURE__*/ new Color(0x000000)
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.meshtoon_vert,
	        fragmentShader: ShaderChunk.meshtoon_frag
	    },
	    matcap: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.bumpmap,
	            UniformsLib.normalmap,
	            UniformsLib.displacementmap,
	            UniformsLib.fog,
	            {
	                matcap: {
	                    value: null
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.meshmatcap_vert,
	        fragmentShader: ShaderChunk.meshmatcap_frag
	    },
	    points: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.points,
	            UniformsLib.fog
	        ]),
	        vertexShader: ShaderChunk.points_vert,
	        fragmentShader: ShaderChunk.points_frag
	    },
	    dashed: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.fog,
	            {
	                scale: {
	                    value: 1
	                },
	                dashSize: {
	                    value: 1
	                },
	                totalSize: {
	                    value: 2
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.linedashed_vert,
	        fragmentShader: ShaderChunk.linedashed_frag
	    },
	    depth: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.displacementmap
	        ]),
	        vertexShader: ShaderChunk.depth_vert,
	        fragmentShader: ShaderChunk.depth_frag
	    },
	    normal: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.bumpmap,
	            UniformsLib.normalmap,
	            UniformsLib.displacementmap,
	            {
	                opacity: {
	                    value: 1.0
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.meshnormal_vert,
	        fragmentShader: ShaderChunk.meshnormal_frag
	    },
	    sprite: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.sprite,
	            UniformsLib.fog
	        ]),
	        vertexShader: ShaderChunk.sprite_vert,
	        fragmentShader: ShaderChunk.sprite_frag
	    },
	    background: {
	        uniforms: {
	            uvTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            t2D: {
	                value: null
	            },
	            backgroundIntensity: {
	                value: 1
	            }
	        },
	        vertexShader: ShaderChunk.background_vert,
	        fragmentShader: ShaderChunk.background_frag
	    },
	    backgroundCube: {
	        uniforms: {
	            envMap: {
	                value: null
	            },
	            flipEnvMap: {
	                value: -1
	            },
	            backgroundBlurriness: {
	                value: 0
	            },
	            backgroundIntensity: {
	                value: 1
	            },
	            backgroundRotation: {
	                value: /*@__PURE__*/ new Matrix3()
	            }
	        },
	        vertexShader: ShaderChunk.backgroundCube_vert,
	        fragmentShader: ShaderChunk.backgroundCube_frag
	    },
	    cube: {
	        uniforms: {
	            tCube: {
	                value: null
	            },
	            tFlip: {
	                value: -1
	            },
	            opacity: {
	                value: 1.0
	            }
	        },
	        vertexShader: ShaderChunk.cube_vert,
	        fragmentShader: ShaderChunk.cube_frag
	    },
	    equirect: {
	        uniforms: {
	            tEquirect: {
	                value: null
	            }
	        },
	        vertexShader: ShaderChunk.equirect_vert,
	        fragmentShader: ShaderChunk.equirect_frag
	    },
	    distanceRGBA: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.common,
	            UniformsLib.displacementmap,
	            {
	                referencePosition: {
	                    value: /*@__PURE__*/ new Vector3()
	                },
	                nearDistance: {
	                    value: 1
	                },
	                farDistance: {
	                    value: 1000
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.distanceRGBA_vert,
	        fragmentShader: ShaderChunk.distanceRGBA_frag
	    },
	    shadow: {
	        uniforms: /*@__PURE__*/ mergeUniforms([
	            UniformsLib.lights,
	            UniformsLib.fog,
	            {
	                color: {
	                    value: /*@__PURE__*/ new Color(0x00000)
	                },
	                opacity: {
	                    value: 1.0
	                }
	            }
	        ]),
	        vertexShader: ShaderChunk.shadow_vert,
	        fragmentShader: ShaderChunk.shadow_frag
	    }
	};
	ShaderLib.physical = {
	    uniforms: /*@__PURE__*/ mergeUniforms([
	        ShaderLib.standard.uniforms,
	        {
	            clearcoat: {
	                value: 0
	            },
	            clearcoatMap: {
	                value: null
	            },
	            clearcoatMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            clearcoatNormalMap: {
	                value: null
	            },
	            clearcoatNormalMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            clearcoatNormalScale: {
	                value: /*@__PURE__*/ new Vector2(1, 1)
	            },
	            clearcoatRoughness: {
	                value: 0
	            },
	            clearcoatRoughnessMap: {
	                value: null
	            },
	            clearcoatRoughnessMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            dispersion: {
	                value: 0
	            },
	            iridescence: {
	                value: 0
	            },
	            iridescenceMap: {
	                value: null
	            },
	            iridescenceMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            iridescenceIOR: {
	                value: 1.3
	            },
	            iridescenceThicknessMinimum: {
	                value: 100
	            },
	            iridescenceThicknessMaximum: {
	                value: 400
	            },
	            iridescenceThicknessMap: {
	                value: null
	            },
	            iridescenceThicknessMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            sheen: {
	                value: 0
	            },
	            sheenColor: {
	                value: /*@__PURE__*/ new Color(0x000000)
	            },
	            sheenColorMap: {
	                value: null
	            },
	            sheenColorMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            sheenRoughness: {
	                value: 1
	            },
	            sheenRoughnessMap: {
	                value: null
	            },
	            sheenRoughnessMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            transmission: {
	                value: 0
	            },
	            transmissionMap: {
	                value: null
	            },
	            transmissionMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            transmissionSamplerSize: {
	                value: /*@__PURE__*/ new Vector2()
	            },
	            transmissionSamplerMap: {
	                value: null
	            },
	            thickness: {
	                value: 0
	            },
	            thicknessMap: {
	                value: null
	            },
	            thicknessMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            attenuationDistance: {
	                value: 0
	            },
	            attenuationColor: {
	                value: /*@__PURE__*/ new Color(0x000000)
	            },
	            specularColor: {
	                value: /*@__PURE__*/ new Color(1, 1, 1)
	            },
	            specularColorMap: {
	                value: null
	            },
	            specularColorMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            specularIntensity: {
	                value: 1
	            },
	            specularIntensityMap: {
	                value: null
	            },
	            specularIntensityMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            },
	            anisotropyVector: {
	                value: /*@__PURE__*/ new Vector2()
	            },
	            anisotropyMap: {
	                value: null
	            },
	            anisotropyMapTransform: {
	                value: /*@__PURE__*/ new Matrix3()
	            }
	        }
	    ]),
	    vertexShader: ShaderChunk.meshphysical_vert,
	    fragmentShader: ShaderChunk.meshphysical_frag
	};
	const _rgb = {
	    r: 0,
	    b: 0,
	    g: 0
	};
	const _e1$1 = /*@__PURE__*/ new Euler();
	const _m1$1 = /*@__PURE__*/ new Matrix4();
	function WebGLBackground(renderer, cubemaps, cubeuvmaps, state, objects, alpha, premultipliedAlpha) {
	    const clearColor = new Color(0x000000);
	    let clearAlpha = alpha === true ? 0 : 1;
	    let planeMesh;
	    let boxMesh;
	    let currentBackground = null;
	    let currentBackgroundVersion = 0;
	    let currentTonemapping = null;
	    function getBackground(scene) {
	        let background = scene.isScene === true ? scene.background : null;
	        if (background && background.isTexture) {
	            const usePMREM = scene.backgroundBlurriness > 0; // use PMREM if the user wants to blur the background
	            background = (usePMREM ? cubeuvmaps : cubemaps).get(background);
	        }
	        return background;
	    }
	    function render(scene) {
	        let forceClear = false;
	        const background = getBackground(scene);
	        if (background === null) {
	            setClear(clearColor, clearAlpha);
	        } else if (background && background.isColor) {
	            setClear(background, 1);
	            forceClear = true;
	        }
	        const environmentBlendMode = renderer.xr.getEnvironmentBlendMode();
	        if (environmentBlendMode === 'additive') {
	            state.buffers.color.setClear(0, 0, 0, 1, premultipliedAlpha);
	        } else if (environmentBlendMode === 'alpha-blend') {
	            state.buffers.color.setClear(0, 0, 0, 0, premultipliedAlpha);
	        }
	        if (renderer.autoClear || forceClear) {
	            // buffers might not be writable which is required to ensure a correct clear
	            state.buffers.depth.setTest(true);
	            state.buffers.depth.setMask(true);
	            state.buffers.color.setMask(true);
	            renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil);
	        }
	    }
	    function addToRenderList(renderList, scene) {
	        const background = getBackground(scene);
	        if (background && (background.isCubeTexture || background.mapping === CubeUVReflectionMapping)) {
	            if (boxMesh === undefined) {
	                boxMesh = new Mesh(new BoxGeometry(1, 1, 1), new ShaderMaterial({
	                    name: 'BackgroundCubeMaterial',
	                    uniforms: cloneUniforms(ShaderLib.backgroundCube.uniforms),
	                    vertexShader: ShaderLib.backgroundCube.vertexShader,
	                    fragmentShader: ShaderLib.backgroundCube.fragmentShader,
	                    side: BackSide,
	                    depthTest: false,
	                    depthWrite: false,
	                    fog: false
	                }));
	                boxMesh.geometry.deleteAttribute('normal');
	                boxMesh.geometry.deleteAttribute('uv');
	                boxMesh.onBeforeRender = function(renderer, scene, camera) {
	                    this.matrixWorld.copyPosition(camera.matrixWorld);
	                };
	                // add "envMap" material property so the renderer can evaluate it like for built-in materials
	                Object.defineProperty(boxMesh.material, 'envMap', {
	                    get: function() {
	                        return this.uniforms.envMap.value;
	                    }
	                });
	                objects.update(boxMesh);
	            }
	            _e1$1.copy(scene.backgroundRotation);
	            // accommodate left-handed frame
	            _e1$1.x *= -1;
	            _e1$1.y *= -1;
	            _e1$1.z *= -1;
	            if (background.isCubeTexture && background.isRenderTargetTexture === false) {
	                // environment maps which are not cube render targets or PMREMs follow a different convention
	                _e1$1.y *= -1;
	                _e1$1.z *= -1;
	            }
	            boxMesh.material.uniforms.envMap.value = background;
	            boxMesh.material.uniforms.flipEnvMap.value = background.isCubeTexture && background.isRenderTargetTexture === false ? -1 : 1;
	            boxMesh.material.uniforms.backgroundBlurriness.value = scene.backgroundBlurriness;
	            boxMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;
	            boxMesh.material.uniforms.backgroundRotation.value.setFromMatrix4(_m1$1.makeRotationFromEuler(_e1$1));
	            boxMesh.material.toneMapped = ColorManagement.getTransfer(background.colorSpace) !== SRGBTransfer;
	            if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) {
	                boxMesh.material.needsUpdate = true;
	                currentBackground = background;
	                currentBackgroundVersion = background.version;
	                currentTonemapping = renderer.toneMapping;
	            }
	            boxMesh.layers.enableAll();
	            // push to the pre-sorted opaque render list
	            renderList.unshift(boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null);
	        } else if (background && background.isTexture) {
	            if (planeMesh === undefined) {
	                planeMesh = new Mesh(new PlaneGeometry(2, 2), new ShaderMaterial({
	                    name: 'BackgroundMaterial',
	                    uniforms: cloneUniforms(ShaderLib.background.uniforms),
	                    vertexShader: ShaderLib.background.vertexShader,
	                    fragmentShader: ShaderLib.background.fragmentShader,
	                    side: FrontSide,
	                    depthTest: false,
	                    depthWrite: false,
	                    fog: false
	                }));
	                planeMesh.geometry.deleteAttribute('normal');
	                // add "map" material property so the renderer can evaluate it like for built-in materials
	                Object.defineProperty(planeMesh.material, 'map', {
	                    get: function() {
	                        return this.uniforms.t2D.value;
	                    }
	                });
	                objects.update(planeMesh);
	            }
	            planeMesh.material.uniforms.t2D.value = background;
	            planeMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;
	            planeMesh.material.toneMapped = ColorManagement.getTransfer(background.colorSpace) !== SRGBTransfer;
	            if (background.matrixAutoUpdate === true) {
	                background.updateMatrix();
	            }
	            planeMesh.material.uniforms.uvTransform.value.copy(background.matrix);
	            if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) {
	                planeMesh.material.needsUpdate = true;
	                currentBackground = background;
	                currentBackgroundVersion = background.version;
	                currentTonemapping = renderer.toneMapping;
	            }
	            planeMesh.layers.enableAll();
	            // push to the pre-sorted opaque render list
	            renderList.unshift(planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null);
	        }
	    }
	    function setClear(color, alpha) {
	        color.getRGB(_rgb, getUnlitUniformColorSpace(renderer));
	        state.buffers.color.setClear(_rgb.r, _rgb.g, _rgb.b, alpha, premultipliedAlpha);
	    }
	    function dispose() {
	        if (boxMesh !== undefined) {
	            boxMesh.geometry.dispose();
	            boxMesh.material.dispose();
	            boxMesh = undefined;
	        }
	        if (planeMesh !== undefined) {
	            planeMesh.geometry.dispose();
	            planeMesh.material.dispose();
	            planeMesh = undefined;
	        }
	    }
	    return {
	        getClearColor: function() {
	            return clearColor;
	        },
	        setClearColor: function(color, alpha = 1) {
	            clearColor.set(color);
	            clearAlpha = alpha;
	            setClear(clearColor, clearAlpha);
	        },
	        getClearAlpha: function() {
	            return clearAlpha;
	        },
	        setClearAlpha: function(alpha) {
	            clearAlpha = alpha;
	            setClear(clearColor, clearAlpha);
	        },
	        render: render,
	        addToRenderList: addToRenderList,
	        dispose: dispose
	    };
	}
	function WebGLBindingStates(gl, attributes) {
	    const maxVertexAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
	    const bindingStates = {};
	    const defaultState = createBindingState(null);
	    let currentState = defaultState;
	    let forceUpdate = false;
	    function setup(object, material, program, geometry, index) {
	        let updateBuffers = false;
	        const state = getBindingState(geometry, program, material);
	        if (currentState !== state) {
	            currentState = state;
	            bindVertexArrayObject(currentState.object);
	        }
	        updateBuffers = needsUpdate(object, geometry, program, index);
	        if (updateBuffers) saveCache(object, geometry, program, index);
	        if (index !== null) {
	            attributes.update(index, gl.ELEMENT_ARRAY_BUFFER);
	        }
	        if (updateBuffers || forceUpdate) {
	            forceUpdate = false;
	            setupVertexAttributes(object, material, program, geometry);
	            if (index !== null) {
	                gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, attributes.get(index).buffer);
	            }
	        }
	    }
	    function createVertexArrayObject() {
	        return gl.createVertexArray();
	    }
	    function bindVertexArrayObject(vao) {
	        return gl.bindVertexArray(vao);
	    }
	    function deleteVertexArrayObject(vao) {
	        return gl.deleteVertexArray(vao);
	    }
	    function getBindingState(geometry, program, material) {
	        const wireframe = material.wireframe === true;
	        let programMap = bindingStates[geometry.id];
	        if (programMap === undefined) {
	            programMap = {};
	            bindingStates[geometry.id] = programMap;
	        }
	        let stateMap = programMap[program.id];
	        if (stateMap === undefined) {
	            stateMap = {};
	            programMap[program.id] = stateMap;
	        }
	        let state = stateMap[wireframe];
	        if (state === undefined) {
	            state = createBindingState(createVertexArrayObject());
	            stateMap[wireframe] = state;
	        }
	        return state;
	    }
	    function createBindingState(vao) {
	        const newAttributes = [];
	        const enabledAttributes = [];
	        const attributeDivisors = [];
	        for(let i = 0; i < maxVertexAttributes; i++){
	            newAttributes[i] = 0;
	            enabledAttributes[i] = 0;
	            attributeDivisors[i] = 0;
	        }
	        return {
	            // for backward compatibility on non-VAO support browser
	            geometry: null,
	            program: null,
	            wireframe: false,
	            newAttributes: newAttributes,
	            enabledAttributes: enabledAttributes,
	            attributeDivisors: attributeDivisors,
	            object: vao,
	            attributes: {},
	            index: null
	        };
	    }
	    function needsUpdate(object, geometry, program, index) {
	        const cachedAttributes = currentState.attributes;
	        const geometryAttributes = geometry.attributes;
	        let attributesNum = 0;
	        const programAttributes = program.getAttributes();
	        for(const name in programAttributes){
	            const programAttribute = programAttributes[name];
	            if (programAttribute.location >= 0) {
	                const cachedAttribute = cachedAttributes[name];
	                let geometryAttribute = geometryAttributes[name];
	                if (geometryAttribute === undefined) {
	                    if (name === 'instanceMatrix' && object.instanceMatrix) geometryAttribute = object.instanceMatrix;
	                    if (name === 'instanceColor' && object.instanceColor) geometryAttribute = object.instanceColor;
	                }
	                if (cachedAttribute === undefined) return true;
	                if (cachedAttribute.attribute !== geometryAttribute) return true;
	                if (geometryAttribute && cachedAttribute.data !== geometryAttribute.data) return true;
	                attributesNum++;
	            }
	        }
	        if (currentState.attributesNum !== attributesNum) return true;
	        if (currentState.index !== index) return true;
	        return false;
	    }
	    function saveCache(object, geometry, program, index) {
	        const cache = {};
	        const attributes = geometry.attributes;
	        let attributesNum = 0;
	        const programAttributes = program.getAttributes();
	        for(const name in programAttributes){
	            const programAttribute = programAttributes[name];
	            if (programAttribute.location >= 0) {
	                let attribute = attributes[name];
	                if (attribute === undefined) {
	                    if (name === 'instanceMatrix' && object.instanceMatrix) attribute = object.instanceMatrix;
	                    if (name === 'instanceColor' && object.instanceColor) attribute = object.instanceColor;
	                }
	                const data = {};
	                data.attribute = attribute;
	                if (attribute && attribute.data) {
	                    data.data = attribute.data;
	                }
	                cache[name] = data;
	                attributesNum++;
	            }
	        }
	        currentState.attributes = cache;
	        currentState.attributesNum = attributesNum;
	        currentState.index = index;
	    }
	    function initAttributes() {
	        const newAttributes = currentState.newAttributes;
	        for(let i = 0, il = newAttributes.length; i < il; i++){
	            newAttributes[i] = 0;
	        }
	    }
	    function enableAttribute(attribute) {
	        enableAttributeAndDivisor(attribute, 0);
	    }
	    function enableAttributeAndDivisor(attribute, meshPerAttribute) {
	        const newAttributes = currentState.newAttributes;
	        const enabledAttributes = currentState.enabledAttributes;
	        const attributeDivisors = currentState.attributeDivisors;
	        newAttributes[attribute] = 1;
	        if (enabledAttributes[attribute] === 0) {
	            gl.enableVertexAttribArray(attribute);
	            enabledAttributes[attribute] = 1;
	        }
	        if (attributeDivisors[attribute] !== meshPerAttribute) {
	            gl.vertexAttribDivisor(attribute, meshPerAttribute);
	            attributeDivisors[attribute] = meshPerAttribute;
	        }
	    }
	    function disableUnusedAttributes() {
	        const newAttributes = currentState.newAttributes;
	        const enabledAttributes = currentState.enabledAttributes;
	        for(let i = 0, il = enabledAttributes.length; i < il; i++){
	            if (enabledAttributes[i] !== newAttributes[i]) {
	                gl.disableVertexAttribArray(i);
	                enabledAttributes[i] = 0;
	            }
	        }
	    }
	    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer) {
	        if (integer === true) {
	            gl.vertexAttribIPointer(index, size, type, stride, offset);
	        } else {
	            gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
	        }
	    }
	    function setupVertexAttributes(object, material, program, geometry) {
	        initAttributes();
	        const geometryAttributes = geometry.attributes;
	        const programAttributes = program.getAttributes();
	        const materialDefaultAttributeValues = material.defaultAttributeValues;
	        for(const name in programAttributes){
	            const programAttribute = programAttributes[name];
	            if (programAttribute.location >= 0) {
	                let geometryAttribute = geometryAttributes[name];
	                if (geometryAttribute === undefined) {
	                    if (name === 'instanceMatrix' && object.instanceMatrix) geometryAttribute = object.instanceMatrix;
	                    if (name === 'instanceColor' && object.instanceColor) geometryAttribute = object.instanceColor;
	                }
	                if (geometryAttribute !== undefined) {
	                    const normalized = geometryAttribute.normalized;
	                    const size = geometryAttribute.itemSize;
	                    const attribute = attributes.get(geometryAttribute);
	                    // TODO Attribute may not be available on context restore
	                    if (attribute === undefined) continue;
	                    const buffer = attribute.buffer;
	                    const type = attribute.type;
	                    const bytesPerElement = attribute.bytesPerElement;
	                    // check for integer attributes
	                    const integer = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
	                    if (geometryAttribute.isInterleavedBufferAttribute) {
	                        const data = geometryAttribute.data;
	                        const stride = data.stride;
	                        const offset = geometryAttribute.offset;
	                        if (data.isInstancedInterleavedBuffer) {
	                            for(let i = 0; i < programAttribute.locationSize; i++){
	                                enableAttributeAndDivisor(programAttribute.location + i, data.meshPerAttribute);
	                            }
	                            if (object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined) {
	                                geometry._maxInstanceCount = data.meshPerAttribute * data.count;
	                            }
	                        } else {
	                            for(let i = 0; i < programAttribute.locationSize; i++){
	                                enableAttribute(programAttribute.location + i);
	                            }
	                        }
	                        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
	                        for(let i = 0; i < programAttribute.locationSize; i++){
	                            vertexAttribPointer(programAttribute.location + i, size / programAttribute.locationSize, type, normalized, stride * bytesPerElement, (offset + size / programAttribute.locationSize * i) * bytesPerElement, integer);
	                        }
	                    } else {
	                        if (geometryAttribute.isInstancedBufferAttribute) {
	                            for(let i = 0; i < programAttribute.locationSize; i++){
	                                enableAttributeAndDivisor(programAttribute.location + i, geometryAttribute.meshPerAttribute);
	                            }
	                            if (object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined) {
	                                geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
	                            }
	                        } else {
	                            for(let i = 0; i < programAttribute.locationSize; i++){
	                                enableAttribute(programAttribute.location + i);
	                            }
	                        }
	                        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
	                        for(let i = 0; i < programAttribute.locationSize; i++){
	                            vertexAttribPointer(programAttribute.location + i, size / programAttribute.locationSize, type, normalized, size * bytesPerElement, size / programAttribute.locationSize * i * bytesPerElement, integer);
	                        }
	                    }
	                } else if (materialDefaultAttributeValues !== undefined) {
	                    const value = materialDefaultAttributeValues[name];
	                    if (value !== undefined) {
	                        switch(value.length){
	                            case 2:
	                                gl.vertexAttrib2fv(programAttribute.location, value);
	                                break;
	                            case 3:
	                                gl.vertexAttrib3fv(programAttribute.location, value);
	                                break;
	                            case 4:
	                                gl.vertexAttrib4fv(programAttribute.location, value);
	                                break;
	                            default:
	                                gl.vertexAttrib1fv(programAttribute.location, value);
	                        }
	                    }
	                }
	            }
	        }
	        disableUnusedAttributes();
	    }
	    function dispose() {
	        reset();
	        for(const geometryId in bindingStates){
	            const programMap = bindingStates[geometryId];
	            for(const programId in programMap){
	                const stateMap = programMap[programId];
	                for(const wireframe in stateMap){
	                    deleteVertexArrayObject(stateMap[wireframe].object);
	                    delete stateMap[wireframe];
	                }
	                delete programMap[programId];
	            }
	            delete bindingStates[geometryId];
	        }
	    }
	    function releaseStatesOfGeometry(geometry) {
	        if (bindingStates[geometry.id] === undefined) return;
	        const programMap = bindingStates[geometry.id];
	        for(const programId in programMap){
	            const stateMap = programMap[programId];
	            for(const wireframe in stateMap){
	                deleteVertexArrayObject(stateMap[wireframe].object);
	                delete stateMap[wireframe];
	            }
	            delete programMap[programId];
	        }
	        delete bindingStates[geometry.id];
	    }
	    function releaseStatesOfProgram(program) {
	        for(const geometryId in bindingStates){
	            const programMap = bindingStates[geometryId];
	            if (programMap[program.id] === undefined) continue;
	            const stateMap = programMap[program.id];
	            for(const wireframe in stateMap){
	                deleteVertexArrayObject(stateMap[wireframe].object);
	                delete stateMap[wireframe];
	            }
	            delete programMap[program.id];
	        }
	    }
	    function reset() {
	        resetDefaultState();
	        forceUpdate = true;
	        if (currentState === defaultState) return;
	        currentState = defaultState;
	        bindVertexArrayObject(currentState.object);
	    }
	    // for backward-compatibility
	    function resetDefaultState() {
	        defaultState.geometry = null;
	        defaultState.program = null;
	        defaultState.wireframe = false;
	    }
	    return {
	        setup: setup,
	        reset: reset,
	        resetDefaultState: resetDefaultState,
	        dispose: dispose,
	        releaseStatesOfGeometry: releaseStatesOfGeometry,
	        releaseStatesOfProgram: releaseStatesOfProgram,
	        initAttributes: initAttributes,
	        enableAttribute: enableAttribute,
	        disableUnusedAttributes: disableUnusedAttributes
	    };
	}
	function WebGLBufferRenderer(gl, extensions, info) {
	    let mode;
	    function setMode(value) {
	        mode = value;
	    }
	    function render(start, count) {
	        gl.drawArrays(mode, start, count);
	        info.update(count, mode, 1);
	    }
	    function renderInstances(start, count, primcount) {
	        if (primcount === 0) return;
	        gl.drawArraysInstanced(mode, start, count, primcount);
	        info.update(count, mode, primcount);
	    }
	    function renderMultiDraw(starts, counts, drawCount) {
	        if (drawCount === 0) return;
	        const extension = extensions.get('WEBGL_multi_draw');
	        extension.multiDrawArraysWEBGL(mode, starts, 0, counts, 0, drawCount);
	        let elementCount = 0;
	        for(let i = 0; i < drawCount; i++){
	            elementCount += counts[i];
	        }
	        info.update(elementCount, mode, 1);
	    }
	    function renderMultiDrawInstances(starts, counts, drawCount, primcount) {
	        if (drawCount === 0) return;
	        const extension = extensions.get('WEBGL_multi_draw');
	        if (extension === null) {
	            for(let i = 0; i < starts.length; i++){
	                renderInstances(starts[i], counts[i], primcount[i]);
	            }
	        } else {
	            extension.multiDrawArraysInstancedWEBGL(mode, starts, 0, counts, 0, primcount, 0, drawCount);
	            let elementCount = 0;
	            for(let i = 0; i < drawCount; i++){
	                elementCount += counts[i] * primcount[i];
	            }
	            info.update(elementCount, mode, 1);
	        }
	    }
	    //
	    this.setMode = setMode;
	    this.render = render;
	    this.renderInstances = renderInstances;
	    this.renderMultiDraw = renderMultiDraw;
	    this.renderMultiDrawInstances = renderMultiDrawInstances;
	}
	function WebGLCapabilities(gl, extensions, parameters, utils) {
	    let maxAnisotropy;
	    function getMaxAnisotropy() {
	        if (maxAnisotropy !== undefined) return maxAnisotropy;
	        if (extensions.has('EXT_texture_filter_anisotropic') === true) {
	            const extension = extensions.get('EXT_texture_filter_anisotropic');
	            maxAnisotropy = gl.getParameter(extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
	        } else {
	            maxAnisotropy = 0;
	        }
	        return maxAnisotropy;
	    }
	    function textureFormatReadable(textureFormat) {
	        if (textureFormat !== RGBAFormat && utils.convert(textureFormat) !== gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT)) {
	            return false;
	        }
	        return true;
	    }
	    function textureTypeReadable(textureType) {
	        const halfFloatSupportedByExt = textureType === HalfFloatType && (extensions.has('EXT_color_buffer_half_float') || extensions.has('EXT_color_buffer_float'));
	        if (textureType !== UnsignedByteType && utils.convert(textureType) !== gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE) && // Edge and Chrome Mac < 52 (#9513)
	        textureType !== FloatType && !halfFloatSupportedByExt) {
	            return false;
	        }
	        return true;
	    }
	    function getMaxPrecision(precision) {
	        if (precision === 'highp') {
	            if (gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT).precision > 0 && gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT).precision > 0) {
	                return 'highp';
	            }
	            precision = 'mediump';
	        }
	        if (precision === 'mediump') {
	            if (gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT).precision > 0 && gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT).precision > 0) {
	                return 'mediump';
	            }
	        }
	        return 'lowp';
	    }
	    let precision = parameters.precision !== undefined ? parameters.precision : 'highp';
	    const maxPrecision = getMaxPrecision(precision);
	    if (maxPrecision !== precision) {
	        console.warn('THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.');
	        precision = maxPrecision;
	    }
	    const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;
	    const reverseDepthBuffer = parameters.reverseDepthBuffer === true && extensions.has('EXT_clip_control');
	    const maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
	    const maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
	    const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
	    const maxCubemapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE);
	    const maxAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
	    const maxVertexUniforms = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS);
	    const maxVaryings = gl.getParameter(gl.MAX_VARYING_VECTORS);
	    const maxFragmentUniforms = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);
	    const vertexTextures = maxVertexTextures > 0;
	    const maxSamples = gl.getParameter(gl.MAX_SAMPLES);
	    return {
	        isWebGL2: true,
	        getMaxAnisotropy: getMaxAnisotropy,
	        getMaxPrecision: getMaxPrecision,
	        textureFormatReadable: textureFormatReadable,
	        textureTypeReadable: textureTypeReadable,
	        precision: precision,
	        logarithmicDepthBuffer: logarithmicDepthBuffer,
	        reverseDepthBuffer: reverseDepthBuffer,
	        maxTextures: maxTextures,
	        maxVertexTextures: maxVertexTextures,
	        maxTextureSize: maxTextureSize,
	        maxCubemapSize: maxCubemapSize,
	        maxAttributes: maxAttributes,
	        maxVertexUniforms: maxVertexUniforms,
	        maxVaryings: maxVaryings,
	        maxFragmentUniforms: maxFragmentUniforms,
	        vertexTextures: vertexTextures,
	        maxSamples: maxSamples
	    };
	}
	function WebGLClipping(properties) {
	    const scope = this;
	    let globalState = null, numGlobalPlanes = 0, localClippingEnabled = false, renderingShadows = false;
	    const plane = new Plane(), viewNormalMatrix = new Matrix3(), uniform = {
	        value: null,
	        needsUpdate: false
	    };
	    this.uniform = uniform;
	    this.numPlanes = 0;
	    this.numIntersection = 0;
	    this.init = function(planes, enableLocalClipping) {
	        const enabled = planes.length !== 0 || enableLocalClipping || // enable state of previous frame - the clipping code has to
	        // run another frame in order to reset the state:
	        numGlobalPlanes !== 0 || localClippingEnabled;
	        localClippingEnabled = enableLocalClipping;
	        numGlobalPlanes = planes.length;
	        return enabled;
	    };
	    this.beginShadows = function() {
	        renderingShadows = true;
	        projectPlanes(null);
	    };
	    this.endShadows = function() {
	        renderingShadows = false;
	    };
	    this.setGlobalState = function(planes, camera) {
	        globalState = projectPlanes(planes, camera, 0);
	    };
	    this.setState = function(material, camera, useCache) {
	        const planes = material.clippingPlanes, clipIntersection = material.clipIntersection, clipShadows = material.clipShadows;
	        const materialProperties = properties.get(material);
	        if (!localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && !clipShadows) {
	            // there's no local clipping
	            if (renderingShadows) {
	                // there's no global clipping
	                projectPlanes(null);
	            } else {
	                resetGlobalState();
	            }
	        } else {
	            const nGlobal = renderingShadows ? 0 : numGlobalPlanes, lGlobal = nGlobal * 4;
	            let dstArray = materialProperties.clippingState || null;
	            uniform.value = dstArray; // ensure unique state
	            dstArray = projectPlanes(planes, camera, lGlobal, useCache);
	            for(let i = 0; i !== lGlobal; ++i){
	                dstArray[i] = globalState[i];
	            }
	            materialProperties.clippingState = dstArray;
	            this.numIntersection = clipIntersection ? this.numPlanes : 0;
	            this.numPlanes += nGlobal;
	        }
	    };
	    function resetGlobalState() {
	        if (uniform.value !== globalState) {
	            uniform.value = globalState;
	            uniform.needsUpdate = numGlobalPlanes > 0;
	        }
	        scope.numPlanes = numGlobalPlanes;
	        scope.numIntersection = 0;
	    }
	    function projectPlanes(planes, camera, dstOffset, skipTransform) {
	        const nPlanes = planes !== null ? planes.length : 0;
	        let dstArray = null;
	        if (nPlanes !== 0) {
	            dstArray = uniform.value;
	            if (skipTransform !== true || dstArray === null) {
	                const flatSize = dstOffset + nPlanes * 4, viewMatrix = camera.matrixWorldInverse;
	                viewNormalMatrix.getNormalMatrix(viewMatrix);
	                if (dstArray === null || dstArray.length < flatSize) {
	                    dstArray = new Float32Array(flatSize);
	                }
	                for(let i = 0, i4 = dstOffset; i !== nPlanes; ++i, i4 += 4){
	                    plane.copy(planes[i]).applyMatrix4(viewMatrix, viewNormalMatrix);
	                    plane.normal.toArray(dstArray, i4);
	                    dstArray[i4 + 3] = plane.constant;
	                }
	            }
	            uniform.value = dstArray;
	            uniform.needsUpdate = true;
	        }
	        scope.numPlanes = nPlanes;
	        scope.numIntersection = 0;
	        return dstArray;
	    }
	}
	function WebGLCubeMaps(renderer) {
	    let cubemaps = new WeakMap();
	    function mapTextureMapping(texture, mapping) {
	        if (mapping === EquirectangularReflectionMapping) {
	            texture.mapping = CubeReflectionMapping;
	        } else if (mapping === EquirectangularRefractionMapping) {
	            texture.mapping = CubeRefractionMapping;
	        }
	        return texture;
	    }
	    function get(texture) {
	        if (texture && texture.isTexture) {
	            const mapping = texture.mapping;
	            if (mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping) {
	                if (cubemaps.has(texture)) {
	                    const cubemap = cubemaps.get(texture).texture;
	                    return mapTextureMapping(cubemap, texture.mapping);
	                } else {
	                    const image = texture.image;
	                    if (image && image.height > 0) {
	                        const renderTarget = new WebGLCubeRenderTarget(image.height);
	                        renderTarget.fromEquirectangularTexture(renderer, texture);
	                        cubemaps.set(texture, renderTarget);
	                        texture.addEventListener('dispose', onTextureDispose);
	                        return mapTextureMapping(renderTarget.texture, texture.mapping);
	                    } else {
	                        // image not yet ready. try the conversion next frame
	                        return null;
	                    }
	                }
	            }
	        }
	        return texture;
	    }
	    function onTextureDispose(event) {
	        const texture = event.target;
	        texture.removeEventListener('dispose', onTextureDispose);
	        const cubemap = cubemaps.get(texture);
	        if (cubemap !== undefined) {
	            cubemaps.delete(texture);
	            cubemap.dispose();
	        }
	    }
	    function dispose() {
	        cubemaps = new WeakMap();
	    }
	    return {
	        get: get,
	        dispose: dispose
	    };
	}
	const LOD_MIN = 4;
	// The standard deviations (radians) associated with the extra mips. These are
	// chosen to approximate a Trowbridge-Reitz distribution function times the
	// geometric shadowing function. These sigma values squared must match the
	// variance #defines in cube_uv_reflection_fragment.glsl.js.
	const EXTRA_LOD_SIGMA = [
	    0.125,
	    0.215,
	    0.35,
	    0.446,
	    0.526,
	    0.582
	];
	// The maximum length of the blur for loop. Smaller sigmas will use fewer
	// samples and exit early, but not recompile the shader.
	const MAX_SAMPLES$1 = 20;
	const _flatCamera = /*@__PURE__*/ new OrthographicCamera();
	const _clearColor = /*@__PURE__*/ new Color();
	let _oldTarget = null;
	let _oldActiveCubeFace = 0;
	let _oldActiveMipmapLevel = 0;
	let _oldXrEnabled = false;
	// Golden Ratio
	const PHI = (1 + Math.sqrt(5)) / 2;
	const INV_PHI = 1 / PHI;
	// Vertices of a dodecahedron (except the opposites, which represent the
	// same axis), used as axis directions evenly spread on a sphere.
	const _axisDirections = [
	    /*@__PURE__*/ new Vector3(-PHI, INV_PHI, 0),
	    /*@__PURE__*/ new Vector3(PHI, INV_PHI, 0),
	    /*@__PURE__*/ new Vector3(-INV_PHI, 0, PHI),
	    /*@__PURE__*/ new Vector3(INV_PHI, 0, PHI),
	    /*@__PURE__*/ new Vector3(0, PHI, -INV_PHI),
	    /*@__PURE__*/ new Vector3(0, PHI, INV_PHI),
	    /*@__PURE__*/ new Vector3(-1, 1, -1),
	    /*@__PURE__*/ new Vector3(1, 1, -1),
	    /*@__PURE__*/ new Vector3(-1, 1, 1),
	    /*@__PURE__*/ new Vector3(1, 1, 1)
	];
	const _origin = /*@__PURE__*/ new Vector3();
	/**
	 * This class generates a Prefiltered, Mipmapped Radiance Environment Map
	 * (PMREM) from a cubeMap environment texture. This allows different levels of
	 * blur to be quickly accessed based on material roughness. It is packed into a
	 * special CubeUV format that allows us to perform custom interpolation so that
	 * we can support nonlinear formats such as RGBE. Unlike a traditional mipmap
	 * chain, it only goes down to the LOD_MIN level (above), and then creates extra
	 * even more filtered 'mips' at the same LOD_MIN resolution, associated with
	 * higher roughness levels. In this way we maintain resolution to smoothly
	 * interpolate diffuse lighting while limiting sampling computation.
	 *
	 * Paper: Fast, Accurate Image-Based Lighting
	 * https://drive.google.com/file/d/15y8r_UpKlU9SvV4ILb0C3qCPecS8pvLz/view
	*/ class PMREMGenerator {
	    /**
		 * Generates a PMREM from a supplied Scene, which can be faster than using an
		 * image if networking bandwidth is low. Optional sigma specifies a blur radius
		 * in radians to be applied to the scene before PMREM generation. Optional near
		 * and far planes ensure the scene is rendered in its entirety.
		 *
		 * @param {Scene} scene
		 * @param {number} sigma
		 * @param {number} near
		 * @param {number} far
		 * @param {Object} [options={}]
		 * @return {WebGLRenderTarget}
		 */ fromScene(scene, sigma = 0, near = 0.1, far = 100, options = {}) {
	        const { size = 256, position = _origin } = options;
	        _oldTarget = this._renderer.getRenderTarget();
	        _oldActiveCubeFace = this._renderer.getActiveCubeFace();
	        _oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
	        _oldXrEnabled = this._renderer.xr.enabled;
	        this._renderer.xr.enabled = false;
	        this._setSize(size);
	        const cubeUVRenderTarget = this._allocateTargets();
	        cubeUVRenderTarget.depthBuffer = true;
	        this._sceneToCubeUV(scene, near, far, cubeUVRenderTarget, position);
	        if (sigma > 0) {
	            this._blur(cubeUVRenderTarget, 0, 0, sigma);
	        }
	        this._applyPMREM(cubeUVRenderTarget);
	        this._cleanup(cubeUVRenderTarget);
	        return cubeUVRenderTarget;
	    }
	    /**
		 * Generates a PMREM from an equirectangular texture, which can be either LDR
		 * or HDR. The ideal input image size is 1k (1024 x 512),
		 * as this matches best with the 256 x 256 cubemap output.
		 * The smallest supported equirectangular image size is 64 x 32.
		 *
		 * @param {Texture} equirectangular
		 * @param {?WebGLRenderTarget} [renderTarget=null] - Optional render target.
		 * @return {WebGLRenderTarget}
		 */ fromEquirectangular(equirectangular, renderTarget = null) {
	        return this._fromTexture(equirectangular, renderTarget);
	    }
	    /**
		 * Generates a PMREM from an cubemap texture, which can be either LDR
		 * or HDR. The ideal input cube size is 256 x 256,
		 * as this matches best with the 256 x 256 cubemap output.
		 * The smallest supported cube size is 16 x 16.
		 *
		 * @param {Texture} cubemap
		 * @param {null} [renderTarget=null] - Optional render target.
		 * @return {WebGLRenderTarget}
		 */ fromCubemap(cubemap, renderTarget = null) {
	        return this._fromTexture(cubemap, renderTarget);
	    }
	    /**
		 * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during
		 * your texture's network fetch for increased concurrency.
		 */ compileCubemapShader() {
	        if (this._cubemapMaterial === null) {
	            this._cubemapMaterial = _getCubemapMaterial();
	            this._compileMaterial(this._cubemapMaterial);
	        }
	    }
	    /**
		 * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during
		 * your texture's network fetch for increased concurrency.
		 */ compileEquirectangularShader() {
	        if (this._equirectMaterial === null) {
	            this._equirectMaterial = _getEquirectMaterial();
	            this._compileMaterial(this._equirectMaterial);
	        }
	    }
	    /**
		 * Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class,
		 * so you should not need more than one PMREMGenerator object. If you do, calling dispose() on
		 * one of them will cause any others to also become unusable.
		 */ dispose() {
	        this._dispose();
	        if (this._cubemapMaterial !== null) this._cubemapMaterial.dispose();
	        if (this._equirectMaterial !== null) this._equirectMaterial.dispose();
	    }
	    // private interface
	    _setSize(cubeSize) {
	        this._lodMax = Math.floor(Math.log2(cubeSize));
	        this._cubeSize = Math.pow(2, this._lodMax);
	    }
	    _dispose() {
	        if (this._blurMaterial !== null) this._blurMaterial.dispose();
	        if (this._pingPongRenderTarget !== null) this._pingPongRenderTarget.dispose();
	        for(let i = 0; i < this._lodPlanes.length; i++){
	            this._lodPlanes[i].dispose();
	        }
	    }
	    _cleanup(outputTarget) {
	        this._renderer.setRenderTarget(_oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel);
	        this._renderer.xr.enabled = _oldXrEnabled;
	        outputTarget.scissorTest = false;
	        _setViewport(outputTarget, 0, 0, outputTarget.width, outputTarget.height);
	    }
	    _fromTexture(texture, renderTarget) {
	        if (texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping) {
	            this._setSize(texture.image.length === 0 ? 16 : texture.image[0].width || texture.image[0].image.width);
	        } else {
	            this._setSize(texture.image.width / 4);
	        }
	        _oldTarget = this._renderer.getRenderTarget();
	        _oldActiveCubeFace = this._renderer.getActiveCubeFace();
	        _oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
	        _oldXrEnabled = this._renderer.xr.enabled;
	        this._renderer.xr.enabled = false;
	        const cubeUVRenderTarget = renderTarget || this._allocateTargets();
	        this._textureToCubeUV(texture, cubeUVRenderTarget);
	        this._applyPMREM(cubeUVRenderTarget);
	        this._cleanup(cubeUVRenderTarget);
	        return cubeUVRenderTarget;
	    }
	    _allocateTargets() {
	        const width = 3 * Math.max(this._cubeSize, 16 * 7);
	        const height = 4 * this._cubeSize;
	        const params = {
	            magFilter: LinearFilter,
	            minFilter: LinearFilter,
	            generateMipmaps: false,
	            type: HalfFloatType,
	            format: RGBAFormat,
	            colorSpace: LinearSRGBColorSpace,
	            depthBuffer: false
	        };
	        const cubeUVRenderTarget = _createRenderTarget(width, height, params);
	        if (this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== width || this._pingPongRenderTarget.height !== height) {
	            if (this._pingPongRenderTarget !== null) {
	                this._dispose();
	            }
	            this._pingPongRenderTarget = _createRenderTarget(width, height, params);
	            const { _lodMax } = this;
	            ({ sizeLods: this._sizeLods, lodPlanes: this._lodPlanes, sigmas: this._sigmas } = _createPlanes(_lodMax));
	            this._blurMaterial = _getBlurShader(_lodMax, width, height);
	        }
	        return cubeUVRenderTarget;
	    }
	    _compileMaterial(material) {
	        const tmpMesh = new Mesh(this._lodPlanes[0], material);
	        this._renderer.compile(tmpMesh, _flatCamera);
	    }
	    _sceneToCubeUV(scene, near, far, cubeUVRenderTarget, position) {
	        const fov = 90;
	        const aspect = 1;
	        const cubeCamera = new PerspectiveCamera(fov, aspect, near, far);
	        const upSign = [
	            1,
	            -1,
	            1,
	            1,
	            1,
	            1
	        ];
	        const forwardSign = [
	            1,
	            1,
	            1,
	            -1,
	            -1,
	            -1
	        ];
	        const renderer = this._renderer;
	        const originalAutoClear = renderer.autoClear;
	        const toneMapping = renderer.toneMapping;
	        renderer.getClearColor(_clearColor);
	        renderer.toneMapping = NoToneMapping;
	        renderer.autoClear = false;
	        const backgroundMaterial = new MeshBasicMaterial({
	            name: 'PMREM.Background',
	            side: BackSide,
	            depthWrite: false,
	            depthTest: false
	        });
	        const backgroundBox = new Mesh(new BoxGeometry(), backgroundMaterial);
	        let useSolidColor = false;
	        const background = scene.background;
	        if (background) {
	            if (background.isColor) {
	                backgroundMaterial.color.copy(background);
	                scene.background = null;
	                useSolidColor = true;
	            }
	        } else {
	            backgroundMaterial.color.copy(_clearColor);
	            useSolidColor = true;
	        }
	        for(let i = 0; i < 6; i++){
	            const col = i % 3;
	            if (col === 0) {
	                cubeCamera.up.set(0, upSign[i], 0);
	                cubeCamera.position.set(position.x, position.y, position.z);
	                cubeCamera.lookAt(position.x + forwardSign[i], position.y, position.z);
	            } else if (col === 1) {
	                cubeCamera.up.set(0, 0, upSign[i]);
	                cubeCamera.position.set(position.x, position.y, position.z);
	                cubeCamera.lookAt(position.x, position.y + forwardSign[i], position.z);
	            } else {
	                cubeCamera.up.set(0, upSign[i], 0);
	                cubeCamera.position.set(position.x, position.y, position.z);
	                cubeCamera.lookAt(position.x, position.y, position.z + forwardSign[i]);
	            }
	            const size = this._cubeSize;
	            _setViewport(cubeUVRenderTarget, col * size, i > 2 ? size : 0, size, size);
	            renderer.setRenderTarget(cubeUVRenderTarget);
	            if (useSolidColor) {
	                renderer.render(backgroundBox, cubeCamera);
	            }
	            renderer.render(scene, cubeCamera);
	        }
	        backgroundBox.geometry.dispose();
	        backgroundBox.material.dispose();
	        renderer.toneMapping = toneMapping;
	        renderer.autoClear = originalAutoClear;
	        scene.background = background;
	    }
	    _textureToCubeUV(texture, cubeUVRenderTarget) {
	        const renderer = this._renderer;
	        const isCubeTexture = texture.mapping === CubeReflectionMapping || texture.mapping === CubeRefractionMapping;
	        if (isCubeTexture) {
	            if (this._cubemapMaterial === null) {
	                this._cubemapMaterial = _getCubemapMaterial();
	            }
	            this._cubemapMaterial.uniforms.flipEnvMap.value = texture.isRenderTargetTexture === false ? -1 : 1;
	        } else {
	            if (this._equirectMaterial === null) {
	                this._equirectMaterial = _getEquirectMaterial();
	            }
	        }
	        const material = isCubeTexture ? this._cubemapMaterial : this._equirectMaterial;
	        const mesh = new Mesh(this._lodPlanes[0], material);
	        const uniforms = material.uniforms;
	        uniforms['envMap'].value = texture;
	        const size = this._cubeSize;
	        _setViewport(cubeUVRenderTarget, 0, 0, 3 * size, 2 * size);
	        renderer.setRenderTarget(cubeUVRenderTarget);
	        renderer.render(mesh, _flatCamera);
	    }
	    _applyPMREM(cubeUVRenderTarget) {
	        const renderer = this._renderer;
	        const autoClear = renderer.autoClear;
	        renderer.autoClear = false;
	        const n = this._lodPlanes.length;
	        for(let i = 1; i < n; i++){
	            const sigma = Math.sqrt(this._sigmas[i] * this._sigmas[i] - this._sigmas[i - 1] * this._sigmas[i - 1]);
	            const poleAxis = _axisDirections[(n - i - 1) % _axisDirections.length];
	            this._blur(cubeUVRenderTarget, i - 1, i, sigma, poleAxis);
	        }
	        renderer.autoClear = autoClear;
	    }
	    /**
		 * This is a two-pass Gaussian blur for a cubemap. Normally this is done
		 * vertically and horizontally, but this breaks down on a cube. Here we apply
		 * the blur latitudinally (around the poles), and then longitudinally (towards
		 * the poles) to approximate the orthogonally-separable blur. It is least
		 * accurate at the poles, but still does a decent job.
		 *
		 * @param {WebGLRenderTarget} cubeUVRenderTarget
		 * @param {number} lodIn
		 * @param {number} lodOut
		 * @param {number} sigma
		 * @param {Vector3} [poleAxis]
		 */ _blur(cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis) {
	        const pingPongRenderTarget = this._pingPongRenderTarget;
	        this._halfBlur(cubeUVRenderTarget, pingPongRenderTarget, lodIn, lodOut, sigma, 'latitudinal', poleAxis);
	        this._halfBlur(pingPongRenderTarget, cubeUVRenderTarget, lodOut, lodOut, sigma, 'longitudinal', poleAxis);
	    }
	    _halfBlur(targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis) {
	        const renderer = this._renderer;
	        const blurMaterial = this._blurMaterial;
	        if (direction !== 'latitudinal' && direction !== 'longitudinal') {
	            console.error('blur direction must be either latitudinal or longitudinal!');
	        }
	        // Number of standard deviations at which to cut off the discrete approximation.
	        const STANDARD_DEVIATIONS = 3;
	        const blurMesh = new Mesh(this._lodPlanes[lodOut], blurMaterial);
	        const blurUniforms = blurMaterial.uniforms;
	        const pixels = this._sizeLods[lodIn] - 1;
	        const radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : 2 * Math.PI / (2 * MAX_SAMPLES$1 - 1);
	        const sigmaPixels = sigmaRadians / radiansPerPixel;
	        const samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : MAX_SAMPLES$1;
	        if (samples > MAX_SAMPLES$1) {
	            console.warn(`sigmaRadians, ${sigmaRadians}, is too large and will clip, as it requested ${samples} samples when the maximum is set to ${MAX_SAMPLES$1}`);
	        }
	        const weights = [];
	        let sum = 0;
	        for(let i = 0; i < MAX_SAMPLES$1; ++i){
	            const x = i / sigmaPixels;
	            const weight = Math.exp(-x * x / 2);
	            weights.push(weight);
	            if (i === 0) {
	                sum += weight;
	            } else if (i < samples) {
	                sum += 2 * weight;
	            }
	        }
	        for(let i = 0; i < weights.length; i++){
	            weights[i] = weights[i] / sum;
	        }
	        blurUniforms['envMap'].value = targetIn.texture;
	        blurUniforms['samples'].value = samples;
	        blurUniforms['weights'].value = weights;
	        blurUniforms['latitudinal'].value = direction === 'latitudinal';
	        if (poleAxis) {
	            blurUniforms['poleAxis'].value = poleAxis;
	        }
	        const { _lodMax } = this;
	        blurUniforms['dTheta'].value = radiansPerPixel;
	        blurUniforms['mipInt'].value = _lodMax - lodIn;
	        const outputSize = this._sizeLods[lodOut];
	        const x = 3 * outputSize * (lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0);
	        const y = 4 * (this._cubeSize - outputSize);
	        _setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize);
	        renderer.setRenderTarget(targetOut);
	        renderer.render(blurMesh, _flatCamera);
	    }
	    constructor(renderer){
	        this._renderer = renderer;
	        this._pingPongRenderTarget = null;
	        this._lodMax = 0;
	        this._cubeSize = 0;
	        this._lodPlanes = [];
	        this._sizeLods = [];
	        this._sigmas = [];
	        this._blurMaterial = null;
	        this._cubemapMaterial = null;
	        this._equirectMaterial = null;
	        this._compileMaterial(this._blurMaterial);
	    }
	}
	function _createPlanes(lodMax) {
	    const lodPlanes = [];
	    const sizeLods = [];
	    const sigmas = [];
	    let lod = lodMax;
	    const totalLods = lodMax - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length;
	    for(let i = 0; i < totalLods; i++){
	        const sizeLod = Math.pow(2, lod);
	        sizeLods.push(sizeLod);
	        let sigma = 1.0 / sizeLod;
	        if (i > lodMax - LOD_MIN) {
	            sigma = EXTRA_LOD_SIGMA[i - lodMax + LOD_MIN - 1];
	        } else if (i === 0) {
	            sigma = 0;
	        }
	        sigmas.push(sigma);
	        const texelSize = 1.0 / (sizeLod - 2);
	        const min = -texelSize;
	        const max = 1 + texelSize;
	        const uv1 = [
	            min,
	            min,
	            max,
	            min,
	            max,
	            max,
	            min,
	            min,
	            max,
	            max,
	            min,
	            max
	        ];
	        const cubeFaces = 6;
	        const vertices = 6;
	        const positionSize = 3;
	        const uvSize = 2;
	        const faceIndexSize = 1;
	        const position = new Float32Array(positionSize * vertices * cubeFaces);
	        const uv = new Float32Array(uvSize * vertices * cubeFaces);
	        const faceIndex = new Float32Array(faceIndexSize * vertices * cubeFaces);
	        for(let face = 0; face < cubeFaces; face++){
	            const x = face % 3 * 2 / 3 - 1;
	            const y = face > 2 ? 0 : -1;
	            const coordinates = [
	                x,
	                y,
	                0,
	                x + 2 / 3,
	                y,
	                0,
	                x + 2 / 3,
	                y + 1,
	                0,
	                x,
	                y,
	                0,
	                x + 2 / 3,
	                y + 1,
	                0,
	                x,
	                y + 1,
	                0
	            ];
	            position.set(coordinates, positionSize * vertices * face);
	            uv.set(uv1, uvSize * vertices * face);
	            const fill = [
	                face,
	                face,
	                face,
	                face,
	                face,
	                face
	            ];
	            faceIndex.set(fill, faceIndexSize * vertices * face);
	        }
	        const planes = new BufferGeometry();
	        planes.setAttribute('position', new BufferAttribute(position, positionSize));
	        planes.setAttribute('uv', new BufferAttribute(uv, uvSize));
	        planes.setAttribute('faceIndex', new BufferAttribute(faceIndex, faceIndexSize));
	        lodPlanes.push(planes);
	        if (lod > LOD_MIN) {
	            lod--;
	        }
	    }
	    return {
	        lodPlanes,
	        sizeLods,
	        sigmas
	    };
	}
	function _createRenderTarget(width, height, params) {
	    const cubeUVRenderTarget = new WebGLRenderTarget(width, height, params);
	    cubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping;
	    cubeUVRenderTarget.texture.name = 'PMREM.cubeUv';
	    cubeUVRenderTarget.scissorTest = true;
	    return cubeUVRenderTarget;
	}
	function _setViewport(target, x, y, width, height) {
	    target.viewport.set(x, y, width, height);
	    target.scissor.set(x, y, width, height);
	}
	function _getBlurShader(lodMax, width, height) {
	    const weights = new Float32Array(MAX_SAMPLES$1);
	    const poleAxis = new Vector3(0, 1, 0);
	    const shaderMaterial = new ShaderMaterial({
	        name: 'SphericalGaussianBlur',
	        defines: {
	            'n': MAX_SAMPLES$1,
	            'CUBEUV_TEXEL_WIDTH': 1.0 / width,
	            'CUBEUV_TEXEL_HEIGHT': 1.0 / height,
	            'CUBEUV_MAX_MIP': `${lodMax}.0`
	        },
	        uniforms: {
	            'envMap': {
	                value: null
	            },
	            'samples': {
	                value: 1
	            },
	            'weights': {
	                value: weights
	            },
	            'latitudinal': {
	                value: false
	            },
	            'dTheta': {
	                value: 0
	            },
	            'mipInt': {
	                value: 0
	            },
	            'poleAxis': {
	                value: poleAxis
	            }
	        },
	        vertexShader: _getCommonVertexShader(),
	        fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,
	        blending: NoBlending,
	        depthTest: false,
	        depthWrite: false
	    });
	    return shaderMaterial;
	}
	function _getEquirectMaterial() {
	    return new ShaderMaterial({
	        name: 'EquirectangularToCubeUV',
	        uniforms: {
	            'envMap': {
	                value: null
	            }
	        },
	        vertexShader: _getCommonVertexShader(),
	        fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;

			#include <common>

			void main() {

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );

			}
		`,
	        blending: NoBlending,
	        depthTest: false,
	        depthWrite: false
	    });
	}
	function _getCubemapMaterial() {
	    return new ShaderMaterial({
	        name: 'CubemapToCubeUV',
	        uniforms: {
	            'envMap': {
	                value: null
	            },
	            'flipEnvMap': {
	                value: -1
	            }
	        },
	        vertexShader: _getCommonVertexShader(),
	        fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,
	        blending: NoBlending,
	        depthTest: false,
	        depthWrite: false
	    });
	}
	function _getCommonVertexShader() {
	    return /* glsl */ `

		precision mediump float;
		precision mediump int;

		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`;
	}
	function WebGLCubeUVMaps(renderer) {
	    let cubeUVmaps = new WeakMap();
	    let pmremGenerator = null;
	    function get(texture) {
	        if (texture && texture.isTexture) {
	            const mapping = texture.mapping;
	            const isEquirectMap = mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping;
	            const isCubeMap = mapping === CubeReflectionMapping || mapping === CubeRefractionMapping;
	            // equirect/cube map to cubeUV conversion
	            if (isEquirectMap || isCubeMap) {
	                let renderTarget = cubeUVmaps.get(texture);
	                const currentPMREMVersion = renderTarget !== undefined ? renderTarget.texture.pmremVersion : 0;
	                if (texture.isRenderTargetTexture && texture.pmremVersion !== currentPMREMVersion) {
	                    if (pmremGenerator === null) pmremGenerator = new PMREMGenerator(renderer);
	                    renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular(texture, renderTarget) : pmremGenerator.fromCubemap(texture, renderTarget);
	                    renderTarget.texture.pmremVersion = texture.pmremVersion;
	                    cubeUVmaps.set(texture, renderTarget);
	                    return renderTarget.texture;
	                } else {
	                    if (renderTarget !== undefined) {
	                        return renderTarget.texture;
	                    } else {
	                        const image = texture.image;
	                        if (isEquirectMap && image && image.height > 0 || isCubeMap && image && isCubeTextureComplete(image)) {
	                            if (pmremGenerator === null) pmremGenerator = new PMREMGenerator(renderer);
	                            renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular(texture) : pmremGenerator.fromCubemap(texture);
	                            renderTarget.texture.pmremVersion = texture.pmremVersion;
	                            cubeUVmaps.set(texture, renderTarget);
	                            texture.addEventListener('dispose', onTextureDispose);
	                            return renderTarget.texture;
	                        } else {
	                            // image not yet ready. try the conversion next frame
	                            return null;
	                        }
	                    }
	                }
	            }
	        }
	        return texture;
	    }
	    function isCubeTextureComplete(image) {
	        let count = 0;
	        const length = 6;
	        for(let i = 0; i < length; i++){
	            if (image[i] !== undefined) count++;
	        }
	        return count === length;
	    }
	    function onTextureDispose(event) {
	        const texture = event.target;
	        texture.removeEventListener('dispose', onTextureDispose);
	        const cubemapUV = cubeUVmaps.get(texture);
	        if (cubemapUV !== undefined) {
	            cubeUVmaps.delete(texture);
	            cubemapUV.dispose();
	        }
	    }
	    function dispose() {
	        cubeUVmaps = new WeakMap();
	        if (pmremGenerator !== null) {
	            pmremGenerator.dispose();
	            pmremGenerator = null;
	        }
	    }
	    return {
	        get: get,
	        dispose: dispose
	    };
	}
	function WebGLExtensions(gl) {
	    const extensions = {};
	    function getExtension(name) {
	        if (extensions[name] !== undefined) {
	            return extensions[name];
	        }
	        let extension;
	        switch(name){
	            case 'WEBGL_depth_texture':
	                extension = gl.getExtension('WEBGL_depth_texture') || gl.getExtension('MOZ_WEBGL_depth_texture') || gl.getExtension('WEBKIT_WEBGL_depth_texture');
	                break;
	            case 'EXT_texture_filter_anisotropic':
	                extension = gl.getExtension('EXT_texture_filter_anisotropic') || gl.getExtension('MOZ_EXT_texture_filter_anisotropic') || gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic');
	                break;
	            case 'WEBGL_compressed_texture_s3tc':
	                extension = gl.getExtension('WEBGL_compressed_texture_s3tc') || gl.getExtension('MOZ_WEBGL_compressed_texture_s3tc') || gl.getExtension('WEBKIT_WEBGL_compressed_texture_s3tc');
	                break;
	            case 'WEBGL_compressed_texture_pvrtc':
	                extension = gl.getExtension('WEBGL_compressed_texture_pvrtc') || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc');
	                break;
	            default:
	                extension = gl.getExtension(name);
	        }
	        extensions[name] = extension;
	        return extension;
	    }
	    return {
	        has: function(name) {
	            return getExtension(name) !== null;
	        },
	        init: function() {
	            getExtension('EXT_color_buffer_float');
	            getExtension('WEBGL_clip_cull_distance');
	            getExtension('OES_texture_float_linear');
	            getExtension('EXT_color_buffer_half_float');
	            getExtension('WEBGL_multisampled_render_to_texture');
	            getExtension('WEBGL_render_shared_exponent');
	        },
	        get: function(name) {
	            const extension = getExtension(name);
	            if (extension === null) {
	                warnOnce('THREE.WebGLRenderer: ' + name + ' extension not supported.');
	            }
	            return extension;
	        }
	    };
	}
	function WebGLGeometries(gl, attributes, info, bindingStates) {
	    const geometries = {};
	    const wireframeAttributes = new WeakMap();
	    function onGeometryDispose(event) {
	        const geometry = event.target;
	        if (geometry.index !== null) {
	            attributes.remove(geometry.index);
	        }
	        for(const name in geometry.attributes){
	            attributes.remove(geometry.attributes[name]);
	        }
	        geometry.removeEventListener('dispose', onGeometryDispose);
	        delete geometries[geometry.id];
	        const attribute = wireframeAttributes.get(geometry);
	        if (attribute) {
	            attributes.remove(attribute);
	            wireframeAttributes.delete(geometry);
	        }
	        bindingStates.releaseStatesOfGeometry(geometry);
	        if (geometry.isInstancedBufferGeometry === true) {
	            delete geometry._maxInstanceCount;
	        }
	        //
	        info.memory.geometries--;
	    }
	    function get(object, geometry) {
	        if (geometries[geometry.id] === true) return geometry;
	        geometry.addEventListener('dispose', onGeometryDispose);
	        geometries[geometry.id] = true;
	        info.memory.geometries++;
	        return geometry;
	    }
	    function update(geometry) {
	        const geometryAttributes = geometry.attributes;
	        // Updating index buffer in VAO now. See WebGLBindingStates.
	        for(const name in geometryAttributes){
	            attributes.update(geometryAttributes[name], gl.ARRAY_BUFFER);
	        }
	    }
	    function updateWireframeAttribute(geometry) {
	        const indices = [];
	        const geometryIndex = geometry.index;
	        const geometryPosition = geometry.attributes.position;
	        let version = 0;
	        if (geometryIndex !== null) {
	            const array = geometryIndex.array;
	            version = geometryIndex.version;
	            for(let i = 0, l = array.length; i < l; i += 3){
	                const a = array[i + 0];
	                const b = array[i + 1];
	                const c = array[i + 2];
	                indices.push(a, b, b, c, c, a);
	            }
	        } else if (geometryPosition !== undefined) {
	            const array = geometryPosition.array;
	            version = geometryPosition.version;
	            for(let i = 0, l = array.length / 3 - 1; i < l; i += 3){
	                const a = i + 0;
	                const b = i + 1;
	                const c = i + 2;
	                indices.push(a, b, b, c, c, a);
	            }
	        } else {
	            return;
	        }
	        const attribute = new (arrayNeedsUint32(indices) ? Uint32BufferAttribute : Uint16BufferAttribute)(indices, 1);
	        attribute.version = version;
	        // Updating index buffer in VAO now. See WebGLBindingStates
	        //
	        const previousAttribute = wireframeAttributes.get(geometry);
	        if (previousAttribute) attributes.remove(previousAttribute);
	        //
	        wireframeAttributes.set(geometry, attribute);
	    }
	    function getWireframeAttribute(geometry) {
	        const currentAttribute = wireframeAttributes.get(geometry);
	        if (currentAttribute) {
	            const geometryIndex = geometry.index;
	            if (geometryIndex !== null) {
	                // if the attribute is obsolete, create a new one
	                if (currentAttribute.version < geometryIndex.version) {
	                    updateWireframeAttribute(geometry);
	                }
	            }
	        } else {
	            updateWireframeAttribute(geometry);
	        }
	        return wireframeAttributes.get(geometry);
	    }
	    return {
	        get: get,
	        update: update,
	        getWireframeAttribute: getWireframeAttribute
	    };
	}
	function WebGLIndexedBufferRenderer(gl, extensions, info) {
	    let mode;
	    function setMode(value) {
	        mode = value;
	    }
	    let type, bytesPerElement;
	    function setIndex(value) {
	        type = value.type;
	        bytesPerElement = value.bytesPerElement;
	    }
	    function render(start, count) {
	        gl.drawElements(mode, count, type, start * bytesPerElement);
	        info.update(count, mode, 1);
	    }
	    function renderInstances(start, count, primcount) {
	        if (primcount === 0) return;
	        gl.drawElementsInstanced(mode, count, type, start * bytesPerElement, primcount);
	        info.update(count, mode, primcount);
	    }
	    function renderMultiDraw(starts, counts, drawCount) {
	        if (drawCount === 0) return;
	        const extension = extensions.get('WEBGL_multi_draw');
	        extension.multiDrawElementsWEBGL(mode, counts, 0, type, starts, 0, drawCount);
	        let elementCount = 0;
	        for(let i = 0; i < drawCount; i++){
	            elementCount += counts[i];
	        }
	        info.update(elementCount, mode, 1);
	    }
	    function renderMultiDrawInstances(starts, counts, drawCount, primcount) {
	        if (drawCount === 0) return;
	        const extension = extensions.get('WEBGL_multi_draw');
	        if (extension === null) {
	            for(let i = 0; i < starts.length; i++){
	                renderInstances(starts[i] / bytesPerElement, counts[i], primcount[i]);
	            }
	        } else {
	            extension.multiDrawElementsInstancedWEBGL(mode, counts, 0, type, starts, 0, primcount, 0, drawCount);
	            let elementCount = 0;
	            for(let i = 0; i < drawCount; i++){
	                elementCount += counts[i] * primcount[i];
	            }
	            info.update(elementCount, mode, 1);
	        }
	    }
	    //
	    this.setMode = setMode;
	    this.setIndex = setIndex;
	    this.render = render;
	    this.renderInstances = renderInstances;
	    this.renderMultiDraw = renderMultiDraw;
	    this.renderMultiDrawInstances = renderMultiDrawInstances;
	}
	function WebGLInfo(gl) {
	    const memory = {
	        geometries: 0,
	        textures: 0
	    };
	    const render = {
	        frame: 0,
	        calls: 0,
	        triangles: 0,
	        points: 0,
	        lines: 0
	    };
	    function update(count, mode, instanceCount) {
	        render.calls++;
	        switch(mode){
	            case gl.TRIANGLES:
	                render.triangles += instanceCount * (count / 3);
	                break;
	            case gl.LINES:
	                render.lines += instanceCount * (count / 2);
	                break;
	            case gl.LINE_STRIP:
	                render.lines += instanceCount * (count - 1);
	                break;
	            case gl.LINE_LOOP:
	                render.lines += instanceCount * count;
	                break;
	            case gl.POINTS:
	                render.points += instanceCount * count;
	                break;
	            default:
	                console.error('THREE.WebGLInfo: Unknown draw mode:', mode);
	                break;
	        }
	    }
	    function reset() {
	        render.calls = 0;
	        render.triangles = 0;
	        render.points = 0;
	        render.lines = 0;
	    }
	    return {
	        memory: memory,
	        render: render,
	        programs: null,
	        autoReset: true,
	        reset: reset,
	        update: update
	    };
	}
	function WebGLMorphtargets(gl, capabilities, textures) {
	    const morphTextures = new WeakMap();
	    const morph = new Vector4();
	    function update(object, geometry, program) {
	        const objectInfluences = object.morphTargetInfluences;
	        // the following encodes morph targets into an array of data textures. Each layer represents a single morph target.
	        const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
	        const morphTargetsCount = morphAttribute !== undefined ? morphAttribute.length : 0;
	        let entry = morphTextures.get(geometry);
	        if (entry === undefined || entry.count !== morphTargetsCount) {
	            if (entry !== undefined) entry.texture.dispose();
	            const hasMorphPosition = geometry.morphAttributes.position !== undefined;
	            const hasMorphNormals = geometry.morphAttributes.normal !== undefined;
	            const hasMorphColors = geometry.morphAttributes.color !== undefined;
	            const morphTargets = geometry.morphAttributes.position || [];
	            const morphNormals = geometry.morphAttributes.normal || [];
	            const morphColors = geometry.morphAttributes.color || [];
	            let vertexDataCount = 0;
	            if (hasMorphPosition === true) vertexDataCount = 1;
	            if (hasMorphNormals === true) vertexDataCount = 2;
	            if (hasMorphColors === true) vertexDataCount = 3;
	            let width = geometry.attributes.position.count * vertexDataCount;
	            let height = 1;
	            if (width > capabilities.maxTextureSize) {
	                height = Math.ceil(width / capabilities.maxTextureSize);
	                width = capabilities.maxTextureSize;
	            }
	            const buffer = new Float32Array(width * height * 4 * morphTargetsCount);
	            const texture = new DataArrayTexture(buffer, width, height, morphTargetsCount);
	            texture.type = FloatType;
	            texture.needsUpdate = true;
	            // fill buffer
	            const vertexDataStride = vertexDataCount * 4;
	            for(let i = 0; i < morphTargetsCount; i++){
	                const morphTarget = morphTargets[i];
	                const morphNormal = morphNormals[i];
	                const morphColor = morphColors[i];
	                const offset = width * height * 4 * i;
	                for(let j = 0; j < morphTarget.count; j++){
	                    const stride = j * vertexDataStride;
	                    if (hasMorphPosition === true) {
	                        morph.fromBufferAttribute(morphTarget, j);
	                        buffer[offset + stride + 0] = morph.x;
	                        buffer[offset + stride + 1] = morph.y;
	                        buffer[offset + stride + 2] = morph.z;
	                        buffer[offset + stride + 3] = 0;
	                    }
	                    if (hasMorphNormals === true) {
	                        morph.fromBufferAttribute(morphNormal, j);
	                        buffer[offset + stride + 4] = morph.x;
	                        buffer[offset + stride + 5] = morph.y;
	                        buffer[offset + stride + 6] = morph.z;
	                        buffer[offset + stride + 7] = 0;
	                    }
	                    if (hasMorphColors === true) {
	                        morph.fromBufferAttribute(morphColor, j);
	                        buffer[offset + stride + 8] = morph.x;
	                        buffer[offset + stride + 9] = morph.y;
	                        buffer[offset + stride + 10] = morph.z;
	                        buffer[offset + stride + 11] = morphColor.itemSize === 4 ? morph.w : 1;
	                    }
	                }
	            }
	            entry = {
	                count: morphTargetsCount,
	                texture: texture,
	                size: new Vector2(width, height)
	            };
	            morphTextures.set(geometry, entry);
	            function disposeTexture() {
	                texture.dispose();
	                morphTextures.delete(geometry);
	                geometry.removeEventListener('dispose', disposeTexture);
	            }
	            geometry.addEventListener('dispose', disposeTexture);
	        }
	        //
	        if (object.isInstancedMesh === true && object.morphTexture !== null) {
	            program.getUniforms().setValue(gl, 'morphTexture', object.morphTexture, textures);
	        } else {
	            let morphInfluencesSum = 0;
	            for(let i = 0; i < objectInfluences.length; i++){
	                morphInfluencesSum += objectInfluences[i];
	            }
	            const morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;
	            program.getUniforms().setValue(gl, 'morphTargetBaseInfluence', morphBaseInfluence);
	            program.getUniforms().setValue(gl, 'morphTargetInfluences', objectInfluences);
	        }
	        program.getUniforms().setValue(gl, 'morphTargetsTexture', entry.texture, textures);
	        program.getUniforms().setValue(gl, 'morphTargetsTextureSize', entry.size);
	    }
	    return {
	        update: update
	    };
	}
	function WebGLObjects(gl, geometries, attributes, info) {
	    let updateMap = new WeakMap();
	    function update(object) {
	        const frame = info.render.frame;
	        const geometry = object.geometry;
	        const buffergeometry = geometries.get(object, geometry);
	        // Update once per frame
	        if (updateMap.get(buffergeometry) !== frame) {
	            geometries.update(buffergeometry);
	            updateMap.set(buffergeometry, frame);
	        }
	        if (object.isInstancedMesh) {
	            if (object.hasEventListener('dispose', onInstancedMeshDispose) === false) {
	                object.addEventListener('dispose', onInstancedMeshDispose);
	            }
	            if (updateMap.get(object) !== frame) {
	                attributes.update(object.instanceMatrix, gl.ARRAY_BUFFER);
	                if (object.instanceColor !== null) {
	                    attributes.update(object.instanceColor, gl.ARRAY_BUFFER);
	                }
	                updateMap.set(object, frame);
	            }
	        }
	        if (object.isSkinnedMesh) {
	            const skeleton = object.skeleton;
	            if (updateMap.get(skeleton) !== frame) {
	                skeleton.update();
	                updateMap.set(skeleton, frame);
	            }
	        }
	        return buffergeometry;
	    }
	    function dispose() {
	        updateMap = new WeakMap();
	    }
	    function onInstancedMeshDispose(event) {
	        const instancedMesh = event.target;
	        instancedMesh.removeEventListener('dispose', onInstancedMeshDispose);
	        attributes.remove(instancedMesh.instanceMatrix);
	        if (instancedMesh.instanceColor !== null) attributes.remove(instancedMesh.instanceColor);
	    }
	    return {
	        update: update,
	        dispose: dispose
	    };
	}
	/**
	 * Uniforms of a program.
	 * Those form a tree structure with a special top-level container for the root,
	 * which you get by calling 'new WebGLUniforms( gl, program )'.
	 *
	 *
	 * Properties of inner nodes including the top-level container:
	 *
	 * .seq - array of nested uniforms
	 * .map - nested uniforms by name
	 *
	 *
	 * Methods of all nodes except the top-level container:
	 *
	 * .setValue( gl, value, [textures] )
	 *
	 * 		uploads a uniform value(s)
	 *  	the 'textures' parameter is needed for sampler uniforms
	 *
	 *
	 * Static methods of the top-level container (textures factorizations):
	 *
	 * .upload( gl, seq, values, textures )
	 *
	 * 		sets uniforms in 'seq' to 'values[id].value'
	 *
	 * .seqWithValue( seq, values ) : filteredSeq
	 *
	 * 		filters 'seq' entries with corresponding entry in values
	 *
	 *
	 * Methods of the top-level container (textures factorizations):
	 *
	 * .setValue( gl, name, value, textures )
	 *
	 * 		sets uniform with  name 'name' to 'value'
	 *
	 * .setOptional( gl, obj, prop )
	 *
	 * 		like .set for an optional property of the object
	 *
	 */ const emptyTexture = /*@__PURE__*/ new Texture$1();
	const emptyShadowTexture = /*@__PURE__*/ new DepthTexture(1, 1);
	const emptyArrayTexture = /*@__PURE__*/ new DataArrayTexture();
	const empty3dTexture = /*@__PURE__*/ new Data3DTexture();
	const emptyCubeTexture = /*@__PURE__*/ new CubeTexture();
	// --- Utilities ---
	// Array Caches (provide typed arrays for temporary by size)
	const arrayCacheF32 = [];
	const arrayCacheI32 = [];
	// Float32Array caches used for uploading Matrix uniforms
	const mat4array = new Float32Array(16);
	const mat3array = new Float32Array(9);
	const mat2array = new Float32Array(4);
	// Flattening for arrays of vectors and matrices
	function flatten(array, nBlocks, blockSize) {
	    const firstElem = array[0];
	    if (firstElem <= 0 || firstElem > 0) return array;
	    // unoptimized: ! isNaN( firstElem )
	    // see http://jacksondunstan.com/articles/983
	    const n = nBlocks * blockSize;
	    let r = arrayCacheF32[n];
	    if (r === undefined) {
	        r = new Float32Array(n);
	        arrayCacheF32[n] = r;
	    }
	    if (nBlocks !== 0) {
	        firstElem.toArray(r, 0);
	        for(let i = 1, offset = 0; i !== nBlocks; ++i){
	            offset += blockSize;
	            array[i].toArray(r, offset);
	        }
	    }
	    return r;
	}
	function arraysEqual(a, b) {
	    if (a.length !== b.length) return false;
	    for(let i = 0, l = a.length; i < l; i++){
	        if (a[i] !== b[i]) return false;
	    }
	    return true;
	}
	function copyArray(a, b) {
	    for(let i = 0, l = b.length; i < l; i++){
	        a[i] = b[i];
	    }
	}
	// Texture unit allocation
	function allocTexUnits(textures, n) {
	    let r = arrayCacheI32[n];
	    if (r === undefined) {
	        r = new Int32Array(n);
	        arrayCacheI32[n] = r;
	    }
	    for(let i = 0; i !== n; ++i){
	        r[i] = textures.allocateTextureUnit();
	    }
	    return r;
	}
	// --- Setters ---
	// Note: Defining these methods externally, because they come in a bunch
	// and this way their names minify.
	// Single scalar
	function setValueV1f(gl, v) {
	    const cache = this.cache;
	    if (cache[0] === v) return;
	    gl.uniform1f(this.addr, v);
	    cache[0] = v;
	}
	// Single float vector (from flat array or THREE.VectorN)
	function setValueV2f(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y) {
	            gl.uniform2f(this.addr, v.x, v.y);
	            cache[0] = v.x;
	            cache[1] = v.y;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform2fv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	function setValueV3f(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) {
	            gl.uniform3f(this.addr, v.x, v.y, v.z);
	            cache[0] = v.x;
	            cache[1] = v.y;
	            cache[2] = v.z;
	        }
	    } else if (v.r !== undefined) {
	        if (cache[0] !== v.r || cache[1] !== v.g || cache[2] !== v.b) {
	            gl.uniform3f(this.addr, v.r, v.g, v.b);
	            cache[0] = v.r;
	            cache[1] = v.g;
	            cache[2] = v.b;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform3fv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	function setValueV4f(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) {
	            gl.uniform4f(this.addr, v.x, v.y, v.z, v.w);
	            cache[0] = v.x;
	            cache[1] = v.y;
	            cache[2] = v.z;
	            cache[3] = v.w;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform4fv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	// Single matrix (from flat array or THREE.MatrixN)
	function setValueM2(gl, v) {
	    const cache = this.cache;
	    const elements = v.elements;
	    if (elements === undefined) {
	        if (arraysEqual(cache, v)) return;
	        gl.uniformMatrix2fv(this.addr, false, v);
	        copyArray(cache, v);
	    } else {
	        if (arraysEqual(cache, elements)) return;
	        mat2array.set(elements);
	        gl.uniformMatrix2fv(this.addr, false, mat2array);
	        copyArray(cache, elements);
	    }
	}
	function setValueM3(gl, v) {
	    const cache = this.cache;
	    const elements = v.elements;
	    if (elements === undefined) {
	        if (arraysEqual(cache, v)) return;
	        gl.uniformMatrix3fv(this.addr, false, v);
	        copyArray(cache, v);
	    } else {
	        if (arraysEqual(cache, elements)) return;
	        mat3array.set(elements);
	        gl.uniformMatrix3fv(this.addr, false, mat3array);
	        copyArray(cache, elements);
	    }
	}
	function setValueM4(gl, v) {
	    const cache = this.cache;
	    const elements = v.elements;
	    if (elements === undefined) {
	        if (arraysEqual(cache, v)) return;
	        gl.uniformMatrix4fv(this.addr, false, v);
	        copyArray(cache, v);
	    } else {
	        if (arraysEqual(cache, elements)) return;
	        mat4array.set(elements);
	        gl.uniformMatrix4fv(this.addr, false, mat4array);
	        copyArray(cache, elements);
	    }
	}
	// Single integer / boolean
	function setValueV1i(gl, v) {
	    const cache = this.cache;
	    if (cache[0] === v) return;
	    gl.uniform1i(this.addr, v);
	    cache[0] = v;
	}
	// Single integer / boolean vector (from flat array or THREE.VectorN)
	function setValueV2i(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y) {
	            gl.uniform2i(this.addr, v.x, v.y);
	            cache[0] = v.x;
	            cache[1] = v.y;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform2iv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	function setValueV3i(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) {
	            gl.uniform3i(this.addr, v.x, v.y, v.z);
	            cache[0] = v.x;
	            cache[1] = v.y;
	            cache[2] = v.z;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform3iv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	function setValueV4i(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) {
	            gl.uniform4i(this.addr, v.x, v.y, v.z, v.w);
	            cache[0] = v.x;
	            cache[1] = v.y;
	            cache[2] = v.z;
	            cache[3] = v.w;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform4iv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	// Single unsigned integer
	function setValueV1ui(gl, v) {
	    const cache = this.cache;
	    if (cache[0] === v) return;
	    gl.uniform1ui(this.addr, v);
	    cache[0] = v;
	}
	// Single unsigned integer vector (from flat array or THREE.VectorN)
	function setValueV2ui(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y) {
	            gl.uniform2ui(this.addr, v.x, v.y);
	            cache[0] = v.x;
	            cache[1] = v.y;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform2uiv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	function setValueV3ui(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) {
	            gl.uniform3ui(this.addr, v.x, v.y, v.z);
	            cache[0] = v.x;
	            cache[1] = v.y;
	            cache[2] = v.z;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform3uiv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	function setValueV4ui(gl, v) {
	    const cache = this.cache;
	    if (v.x !== undefined) {
	        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) {
	            gl.uniform4ui(this.addr, v.x, v.y, v.z, v.w);
	            cache[0] = v.x;
	            cache[1] = v.y;
	            cache[2] = v.z;
	            cache[3] = v.w;
	        }
	    } else {
	        if (arraysEqual(cache, v)) return;
	        gl.uniform4uiv(this.addr, v);
	        copyArray(cache, v);
	    }
	}
	// Single texture (2D / Cube)
	function setValueT1(gl, v, textures) {
	    const cache = this.cache;
	    const unit = textures.allocateTextureUnit();
	    if (cache[0] !== unit) {
	        gl.uniform1i(this.addr, unit);
	        cache[0] = unit;
	    }
	    let emptyTexture2D;
	    if (this.type === gl.SAMPLER_2D_SHADOW) {
	        emptyShadowTexture.compareFunction = LessEqualCompare; // #28670
	        emptyTexture2D = emptyShadowTexture;
	    } else {
	        emptyTexture2D = emptyTexture;
	    }
	    textures.setTexture2D(v || emptyTexture2D, unit);
	}
	function setValueT3D1(gl, v, textures) {
	    const cache = this.cache;
	    const unit = textures.allocateTextureUnit();
	    if (cache[0] !== unit) {
	        gl.uniform1i(this.addr, unit);
	        cache[0] = unit;
	    }
	    textures.setTexture3D(v || empty3dTexture, unit);
	}
	function setValueT6(gl, v, textures) {
	    const cache = this.cache;
	    const unit = textures.allocateTextureUnit();
	    if (cache[0] !== unit) {
	        gl.uniform1i(this.addr, unit);
	        cache[0] = unit;
	    }
	    textures.setTextureCube(v || emptyCubeTexture, unit);
	}
	function setValueT2DArray1(gl, v, textures) {
	    const cache = this.cache;
	    const unit = textures.allocateTextureUnit();
	    if (cache[0] !== unit) {
	        gl.uniform1i(this.addr, unit);
	        cache[0] = unit;
	    }
	    textures.setTexture2DArray(v || emptyArrayTexture, unit);
	}
	// Helper to pick the right setter for the singular case
	function getSingularSetter(type) {
	    switch(type){
	        case 0x1406:
	            return setValueV1f; // FLOAT
	        case 0x8b50:
	            return setValueV2f; // _VEC2
	        case 0x8b51:
	            return setValueV3f; // _VEC3
	        case 0x8b52:
	            return setValueV4f; // _VEC4
	        case 0x8b5a:
	            return setValueM2; // _MAT2
	        case 0x8b5b:
	            return setValueM3; // _MAT3
	        case 0x8b5c:
	            return setValueM4; // _MAT4
	        case 0x1404:
	        case 0x8b56:
	            return setValueV1i; // INT, BOOL
	        case 0x8b53:
	        case 0x8b57:
	            return setValueV2i; // _VEC2
	        case 0x8b54:
	        case 0x8b58:
	            return setValueV3i; // _VEC3
	        case 0x8b55:
	        case 0x8b59:
	            return setValueV4i; // _VEC4
	        case 0x1405:
	            return setValueV1ui; // UINT
	        case 0x8dc6:
	            return setValueV2ui; // _VEC2
	        case 0x8dc7:
	            return setValueV3ui; // _VEC3
	        case 0x8dc8:
	            return setValueV4ui; // _VEC4
	        case 0x8b5e:
	        case 0x8d66:
	        case 0x8dca:
	        case 0x8dd2:
	        case 0x8b62:
	            return setValueT1;
	        case 0x8b5f:
	        case 0x8dcb:
	        case 0x8dd3:
	            return setValueT3D1;
	        case 0x8b60:
	        case 0x8dcc:
	        case 0x8dd4:
	        case 0x8dc5:
	            return setValueT6;
	        case 0x8dc1:
	        case 0x8dcf:
	        case 0x8dd7:
	        case 0x8dc4:
	            return setValueT2DArray1;
	    }
	}
	// Array of scalars
	function setValueV1fArray(gl, v) {
	    gl.uniform1fv(this.addr, v);
	}
	// Array of vectors (from flat array or array of THREE.VectorN)
	function setValueV2fArray(gl, v) {
	    const data = flatten(v, this.size, 2);
	    gl.uniform2fv(this.addr, data);
	}
	function setValueV3fArray(gl, v) {
	    const data = flatten(v, this.size, 3);
	    gl.uniform3fv(this.addr, data);
	}
	function setValueV4fArray(gl, v) {
	    const data = flatten(v, this.size, 4);
	    gl.uniform4fv(this.addr, data);
	}
	// Array of matrices (from flat array or array of THREE.MatrixN)
	function setValueM2Array(gl, v) {
	    const data = flatten(v, this.size, 4);
	    gl.uniformMatrix2fv(this.addr, false, data);
	}
	function setValueM3Array(gl, v) {
	    const data = flatten(v, this.size, 9);
	    gl.uniformMatrix3fv(this.addr, false, data);
	}
	function setValueM4Array(gl, v) {
	    const data = flatten(v, this.size, 16);
	    gl.uniformMatrix4fv(this.addr, false, data);
	}
	// Array of integer / boolean
	function setValueV1iArray(gl, v) {
	    gl.uniform1iv(this.addr, v);
	}
	// Array of integer / boolean vectors (from flat array)
	function setValueV2iArray(gl, v) {
	    gl.uniform2iv(this.addr, v);
	}
	function setValueV3iArray(gl, v) {
	    gl.uniform3iv(this.addr, v);
	}
	function setValueV4iArray(gl, v) {
	    gl.uniform4iv(this.addr, v);
	}
	// Array of unsigned integer
	function setValueV1uiArray(gl, v) {
	    gl.uniform1uiv(this.addr, v);
	}
	// Array of unsigned integer vectors (from flat array)
	function setValueV2uiArray(gl, v) {
	    gl.uniform2uiv(this.addr, v);
	}
	function setValueV3uiArray(gl, v) {
	    gl.uniform3uiv(this.addr, v);
	}
	function setValueV4uiArray(gl, v) {
	    gl.uniform4uiv(this.addr, v);
	}
	// Array of textures (2D / 3D / Cube / 2DArray)
	function setValueT1Array(gl, v, textures) {
	    const cache = this.cache;
	    const n = v.length;
	    const units = allocTexUnits(textures, n);
	    if (!arraysEqual(cache, units)) {
	        gl.uniform1iv(this.addr, units);
	        copyArray(cache, units);
	    }
	    for(let i = 0; i !== n; ++i){
	        textures.setTexture2D(v[i] || emptyTexture, units[i]);
	    }
	}
	function setValueT3DArray(gl, v, textures) {
	    const cache = this.cache;
	    const n = v.length;
	    const units = allocTexUnits(textures, n);
	    if (!arraysEqual(cache, units)) {
	        gl.uniform1iv(this.addr, units);
	        copyArray(cache, units);
	    }
	    for(let i = 0; i !== n; ++i){
	        textures.setTexture3D(v[i] || empty3dTexture, units[i]);
	    }
	}
	function setValueT6Array(gl, v, textures) {
	    const cache = this.cache;
	    const n = v.length;
	    const units = allocTexUnits(textures, n);
	    if (!arraysEqual(cache, units)) {
	        gl.uniform1iv(this.addr, units);
	        copyArray(cache, units);
	    }
	    for(let i = 0; i !== n; ++i){
	        textures.setTextureCube(v[i] || emptyCubeTexture, units[i]);
	    }
	}
	function setValueT2DArrayArray(gl, v, textures) {
	    const cache = this.cache;
	    const n = v.length;
	    const units = allocTexUnits(textures, n);
	    if (!arraysEqual(cache, units)) {
	        gl.uniform1iv(this.addr, units);
	        copyArray(cache, units);
	    }
	    for(let i = 0; i !== n; ++i){
	        textures.setTexture2DArray(v[i] || emptyArrayTexture, units[i]);
	    }
	}
	// Helper to pick the right setter for a pure (bottom-level) array
	function getPureArraySetter(type) {
	    switch(type){
	        case 0x1406:
	            return setValueV1fArray; // FLOAT
	        case 0x8b50:
	            return setValueV2fArray; // _VEC2
	        case 0x8b51:
	            return setValueV3fArray; // _VEC3
	        case 0x8b52:
	            return setValueV4fArray; // _VEC4
	        case 0x8b5a:
	            return setValueM2Array; // _MAT2
	        case 0x8b5b:
	            return setValueM3Array; // _MAT3
	        case 0x8b5c:
	            return setValueM4Array; // _MAT4
	        case 0x1404:
	        case 0x8b56:
	            return setValueV1iArray; // INT, BOOL
	        case 0x8b53:
	        case 0x8b57:
	            return setValueV2iArray; // _VEC2
	        case 0x8b54:
	        case 0x8b58:
	            return setValueV3iArray; // _VEC3
	        case 0x8b55:
	        case 0x8b59:
	            return setValueV4iArray; // _VEC4
	        case 0x1405:
	            return setValueV1uiArray; // UINT
	        case 0x8dc6:
	            return setValueV2uiArray; // _VEC2
	        case 0x8dc7:
	            return setValueV3uiArray; // _VEC3
	        case 0x8dc8:
	            return setValueV4uiArray; // _VEC4
	        case 0x8b5e:
	        case 0x8d66:
	        case 0x8dca:
	        case 0x8dd2:
	        case 0x8b62:
	            return setValueT1Array;
	        case 0x8b5f:
	        case 0x8dcb:
	        case 0x8dd3:
	            return setValueT3DArray;
	        case 0x8b60:
	        case 0x8dcc:
	        case 0x8dd4:
	        case 0x8dc5:
	            return setValueT6Array;
	        case 0x8dc1:
	        case 0x8dcf:
	        case 0x8dd7:
	        case 0x8dc4:
	            return setValueT2DArrayArray;
	    }
	}
	// --- Uniform Classes ---
	class SingleUniform {
	    constructor(id, activeInfo, addr){
	        this.id = id;
	        this.addr = addr;
	        this.cache = [];
	        this.type = activeInfo.type;
	        this.setValue = getSingularSetter(activeInfo.type);
	    // this.path = activeInfo.name; // DEBUG
	    }
	}
	class PureArrayUniform {
	    constructor(id, activeInfo, addr){
	        this.id = id;
	        this.addr = addr;
	        this.cache = [];
	        this.type = activeInfo.type;
	        this.size = activeInfo.size;
	        this.setValue = getPureArraySetter(activeInfo.type);
	    // this.path = activeInfo.name; // DEBUG
	    }
	}
	class StructuredUniform {
	    setValue(gl, value, textures) {
	        const seq = this.seq;
	        for(let i = 0, n = seq.length; i !== n; ++i){
	            const u = seq[i];
	            u.setValue(gl, value[u.id], textures);
	        }
	    }
	    constructor(id){
	        this.id = id;
	        this.seq = [];
	        this.map = {};
	    }
	}
	// --- Top-level ---
	// Parser - builds up the property tree from the path strings
	const RePathPart = /(\w+)(\])?(\[|\.)?/g;
	// extracts
	// 	- the identifier (member name or array index)
	//  - followed by an optional right bracket (found when array index)
	//  - followed by an optional left bracket or dot (type of subscript)
	//
	// Note: These portions can be read in a non-overlapping fashion and
	// allow straightforward parsing of the hierarchy that WebGL encodes
	// in the uniform names.
	function addUniform(container, uniformObject) {
	    container.seq.push(uniformObject);
	    container.map[uniformObject.id] = uniformObject;
	}
	function parseUniform(activeInfo, addr, container) {
	    const path = activeInfo.name, pathLength = path.length;
	    // reset RegExp object, because of the early exit of a previous run
	    RePathPart.lastIndex = 0;
	    while(true){
	        const match = RePathPart.exec(path), matchEnd = RePathPart.lastIndex;
	        let id = match[1];
	        const idIsIndex = match[2] === ']', subscript = match[3];
	        if (idIsIndex) id = id | 0; // convert to integer
	        if (subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength) {
	            // bare name or "pure" bottom-level array "[0]" suffix
	            addUniform(container, subscript === undefined ? new SingleUniform(id, activeInfo, addr) : new PureArrayUniform(id, activeInfo, addr));
	            break;
	        } else {
	            // step into inner node / create it in case it doesn't exist
	            const map = container.map;
	            let next = map[id];
	            if (next === undefined) {
	                next = new StructuredUniform(id);
	                addUniform(container, next);
	            }
	            container = next;
	        }
	    }
	}
	// Root Container
	class WebGLUniforms {
	    setValue(gl, name, value, textures) {
	        const u = this.map[name];
	        if (u !== undefined) u.setValue(gl, value, textures);
	    }
	    setOptional(gl, object, name) {
	        const v = object[name];
	        if (v !== undefined) this.setValue(gl, name, v);
	    }
	    static upload(gl, seq, values, textures) {
	        for(let i = 0, n = seq.length; i !== n; ++i){
	            const u = seq[i], v = values[u.id];
	            if (v.needsUpdate !== false) {
	                // note: always updating when .needsUpdate is undefined
	                u.setValue(gl, v.value, textures);
	            }
	        }
	    }
	    static seqWithValue(seq, values) {
	        const r = [];
	        for(let i = 0, n = seq.length; i !== n; ++i){
	            const u = seq[i];
	            if (u.id in values) r.push(u);
	        }
	        return r;
	    }
	    constructor(gl, program){
	        this.seq = [];
	        this.map = {};
	        const n = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
	        for(let i = 0; i < n; ++i){
	            const info = gl.getActiveUniform(program, i), addr = gl.getUniformLocation(program, info.name);
	            parseUniform(info, addr, this);
	        }
	    }
	}
	function WebGLShader(gl, type, string) {
	    const shader = gl.createShader(type);
	    gl.shaderSource(shader, string);
	    gl.compileShader(shader);
	    return shader;
	}
	// From https://www.khronos.org/registry/webgl/extensions/KHR_parallel_shader_compile/
	const COMPLETION_STATUS_KHR = 0x91B1;
	let programIdCount = 0;
	function handleSource(string, errorLine) {
	    const lines = string.split('\n');
	    const lines2 = [];
	    const from = Math.max(errorLine - 6, 0);
	    const to = Math.min(errorLine + 6, lines.length);
	    for(let i = from; i < to; i++){
	        const line = i + 1;
	        lines2.push(`${line === errorLine ? '>' : ' '} ${line}: ${lines[i]}`);
	    }
	    return lines2.join('\n');
	}
	const _m0 = /*@__PURE__*/ new Matrix3();
	function getEncodingComponents(colorSpace) {
	    ColorManagement._getMatrix(_m0, ColorManagement.workingColorSpace, colorSpace);
	    const encodingMatrix = `mat3( ${_m0.elements.map((v)=>v.toFixed(4))} )`;
	    switch(ColorManagement.getTransfer(colorSpace)){
	        case LinearTransfer:
	            return [
	                encodingMatrix,
	                'LinearTransferOETF'
	            ];
	        case SRGBTransfer:
	            return [
	                encodingMatrix,
	                'sRGBTransferOETF'
	            ];
	        default:
	            console.warn('THREE.WebGLProgram: Unsupported color space: ', colorSpace);
	            return [
	                encodingMatrix,
	                'LinearTransferOETF'
	            ];
	    }
	}
	function getShaderErrors(gl, shader, type) {
	    const status = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
	    const errors = gl.getShaderInfoLog(shader).trim();
	    if (status && errors === '') return '';
	    const errorMatches = /ERROR: 0:(\d+)/.exec(errors);
	    if (errorMatches) {
	        // --enable-privileged-webgl-extension
	        // console.log( '**' + type + '**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );
	        const errorLine = parseInt(errorMatches[1]);
	        return type.toUpperCase() + '\n\n' + errors + '\n\n' + handleSource(gl.getShaderSource(shader), errorLine);
	    } else {
	        return errors;
	    }
	}
	function getTexelEncodingFunction(functionName, colorSpace) {
	    const components = getEncodingComponents(colorSpace);
	    return [
	        `vec4 ${functionName}( vec4 value ) {`,
	        `	return ${components[1]}( vec4( value.rgb * ${components[0]}, value.a ) );`,
	        '}'
	    ].join('\n');
	}
	function getToneMappingFunction(functionName, toneMapping) {
	    let toneMappingName;
	    switch(toneMapping){
	        case LinearToneMapping:
	            toneMappingName = 'Linear';
	            break;
	        case ReinhardToneMapping:
	            toneMappingName = 'Reinhard';
	            break;
	        case CineonToneMapping:
	            toneMappingName = 'Cineon';
	            break;
	        case ACESFilmicToneMapping:
	            toneMappingName = 'ACESFilmic';
	            break;
	        case AgXToneMapping:
	            toneMappingName = 'AgX';
	            break;
	        case NeutralToneMapping:
	            toneMappingName = 'Neutral';
	            break;
	        case CustomToneMapping:
	            toneMappingName = 'Custom';
	            break;
	        default:
	            console.warn('THREE.WebGLProgram: Unsupported toneMapping:', toneMapping);
	            toneMappingName = 'Linear';
	    }
	    return 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';
	}
	const _v0 = /*@__PURE__*/ new Vector3();
	function getLuminanceFunction() {
	    ColorManagement.getLuminanceCoefficients(_v0);
	    const r = _v0.x.toFixed(4);
	    const g = _v0.y.toFixed(4);
	    const b = _v0.z.toFixed(4);
	    return [
	        'float luminance( const in vec3 rgb ) {',
	        `	const vec3 weights = vec3( ${r}, ${g}, ${b} );`,
	        '	return dot( weights, rgb );',
	        '}'
	    ].join('\n');
	}
	function generateVertexExtensions(parameters) {
	    const chunks = [
	        parameters.extensionClipCullDistance ? '#extension GL_ANGLE_clip_cull_distance : require' : '',
	        parameters.extensionMultiDraw ? '#extension GL_ANGLE_multi_draw : require' : ''
	    ];
	    return chunks.filter(filterEmptyLine).join('\n');
	}
	function generateDefines(defines) {
	    const chunks = [];
	    for(const name in defines){
	        const value = defines[name];
	        if (value === false) continue;
	        chunks.push('#define ' + name + ' ' + value);
	    }
	    return chunks.join('\n');
	}
	function fetchAttributeLocations(gl, program) {
	    const attributes = {};
	    const n = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
	    for(let i = 0; i < n; i++){
	        const info = gl.getActiveAttrib(program, i);
	        const name = info.name;
	        let locationSize = 1;
	        if (info.type === gl.FLOAT_MAT2) locationSize = 2;
	        if (info.type === gl.FLOAT_MAT3) locationSize = 3;
	        if (info.type === gl.FLOAT_MAT4) locationSize = 4;
	        // console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );
	        attributes[name] = {
	            type: info.type,
	            location: gl.getAttribLocation(program, name),
	            locationSize: locationSize
	        };
	    }
	    return attributes;
	}
	function filterEmptyLine(string) {
	    return string !== '';
	}
	function replaceLightNums(string, parameters) {
	    const numSpotLightCoords = parameters.numSpotLightShadows + parameters.numSpotLightMaps - parameters.numSpotLightShadowsWithMaps;
	    return string.replace(/NUM_DIR_LIGHTS/g, parameters.numDirLights).replace(/NUM_SPOT_LIGHTS/g, parameters.numSpotLights).replace(/NUM_SPOT_LIGHT_MAPS/g, parameters.numSpotLightMaps).replace(/NUM_SPOT_LIGHT_COORDS/g, numSpotLightCoords).replace(/NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g, parameters.numPointLights).replace(/NUM_HEMI_LIGHTS/g, parameters.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g, parameters.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g, parameters.numSpotLightShadowsWithMaps).replace(/NUM_SPOT_LIGHT_SHADOWS/g, parameters.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows);
	}
	function replaceClippingPlaneNums(string, parameters) {
	    return string.replace(/NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g, parameters.numClippingPlanes - parameters.numClipIntersection);
	}
	// Resolve Includes
	const includePattern = /^[ \t]*#include +<([\w\d./]+)>/gm;
	function resolveIncludes(string) {
	    return string.replace(includePattern, includeReplacer);
	}
	const shaderChunkMap = new Map();
	function includeReplacer(match, include) {
	    let string = ShaderChunk[include];
	    if (string === undefined) {
	        const newInclude = shaderChunkMap.get(include);
	        if (newInclude !== undefined) {
	            string = ShaderChunk[newInclude];
	            console.warn('THREE.WebGLRenderer: Shader chunk "%s" has been deprecated. Use "%s" instead.', include, newInclude);
	        } else {
	            throw new Error('Can not resolve #include <' + include + '>');
	        }
	    }
	    return resolveIncludes(string);
	}
	// Unroll Loops
	const unrollLoopPattern = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
	function unrollLoops(string) {
	    return string.replace(unrollLoopPattern, loopReplacer);
	}
	function loopReplacer(match, start, end, snippet) {
	    let string = '';
	    for(let i = parseInt(start); i < parseInt(end); i++){
	        string += snippet.replace(/\[\s*i\s*\]/g, '[ ' + i + ' ]').replace(/UNROLLED_LOOP_INDEX/g, i);
	    }
	    return string;
	}
	//
	function generatePrecision(parameters) {
	    let precisionstring = `precision ${parameters.precision} float;
	precision ${parameters.precision} int;
	precision ${parameters.precision} sampler2D;
	precision ${parameters.precision} samplerCube;
	precision ${parameters.precision} sampler3D;
	precision ${parameters.precision} sampler2DArray;
	precision ${parameters.precision} sampler2DShadow;
	precision ${parameters.precision} samplerCubeShadow;
	precision ${parameters.precision} sampler2DArrayShadow;
	precision ${parameters.precision} isampler2D;
	precision ${parameters.precision} isampler3D;
	precision ${parameters.precision} isamplerCube;
	precision ${parameters.precision} isampler2DArray;
	precision ${parameters.precision} usampler2D;
	precision ${parameters.precision} usampler3D;
	precision ${parameters.precision} usamplerCube;
	precision ${parameters.precision} usampler2DArray;
	`;
	    if (parameters.precision === 'highp') {
	        precisionstring += '\n#define HIGH_PRECISION';
	    } else if (parameters.precision === 'mediump') {
	        precisionstring += '\n#define MEDIUM_PRECISION';
	    } else if (parameters.precision === 'lowp') {
	        precisionstring += '\n#define LOW_PRECISION';
	    }
	    return precisionstring;
	}
	function generateShadowMapTypeDefine(parameters) {
	    let shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';
	    if (parameters.shadowMapType === PCFShadowMap) {
	        shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';
	    } else if (parameters.shadowMapType === PCFSoftShadowMap) {
	        shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';
	    } else if (parameters.shadowMapType === VSMShadowMap) {
	        shadowMapTypeDefine = 'SHADOWMAP_TYPE_VSM';
	    }
	    return shadowMapTypeDefine;
	}
	function generateEnvMapTypeDefine(parameters) {
	    let envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
	    if (parameters.envMap) {
	        switch(parameters.envMapMode){
	            case CubeReflectionMapping:
	            case CubeRefractionMapping:
	                envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
	                break;
	            case CubeUVReflectionMapping:
	                envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
	                break;
	        }
	    }
	    return envMapTypeDefine;
	}
	function generateEnvMapModeDefine(parameters) {
	    let envMapModeDefine = 'ENVMAP_MODE_REFLECTION';
	    if (parameters.envMap) {
	        switch(parameters.envMapMode){
	            case CubeRefractionMapping:
	                envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
	                break;
	        }
	    }
	    return envMapModeDefine;
	}
	function generateEnvMapBlendingDefine(parameters) {
	    let envMapBlendingDefine = 'ENVMAP_BLENDING_NONE';
	    if (parameters.envMap) {
	        switch(parameters.combine){
	            case MultiplyOperation:
	                envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
	                break;
	            case MixOperation:
	                envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
	                break;
	            case AddOperation:
	                envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
	                break;
	        }
	    }
	    return envMapBlendingDefine;
	}
	function generateCubeUVSize(parameters) {
	    const imageHeight = parameters.envMapCubeUVHeight;
	    if (imageHeight === null) return null;
	    const maxMip = Math.log2(imageHeight) - 2;
	    const texelHeight = 1.0 / imageHeight;
	    const texelWidth = 1.0 / (3 * Math.max(Math.pow(2, maxMip), 7 * 16));
	    return {
	        texelWidth,
	        texelHeight,
	        maxMip
	    };
	}
	function WebGLProgram(renderer, cacheKey, parameters, bindingStates) {
	    // TODO Send this event to Three.js DevTools
	    // console.log( 'WebGLProgram', cacheKey );
	    const gl = renderer.getContext();
	    const defines = parameters.defines;
	    let vertexShader = parameters.vertexShader;
	    let fragmentShader = parameters.fragmentShader;
	    const shadowMapTypeDefine = generateShadowMapTypeDefine(parameters);
	    const envMapTypeDefine = generateEnvMapTypeDefine(parameters);
	    const envMapModeDefine = generateEnvMapModeDefine(parameters);
	    const envMapBlendingDefine = generateEnvMapBlendingDefine(parameters);
	    const envMapCubeUVSize = generateCubeUVSize(parameters);
	    const customVertexExtensions = generateVertexExtensions(parameters);
	    const customDefines = generateDefines(defines);
	    const program = gl.createProgram();
	    let prefixVertex, prefixFragment;
	    let versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\n' : '';
	    if (parameters.isRawShaderMaterial) {
	        prefixVertex = [
	            '#define SHADER_TYPE ' + parameters.shaderType,
	            '#define SHADER_NAME ' + parameters.shaderName,
	            customDefines
	        ].filter(filterEmptyLine).join('\n');
	        if (prefixVertex.length > 0) {
	            prefixVertex += '\n';
	        }
	        prefixFragment = [
	            '#define SHADER_TYPE ' + parameters.shaderType,
	            '#define SHADER_NAME ' + parameters.shaderName,
	            customDefines
	        ].filter(filterEmptyLine).join('\n');
	        if (prefixFragment.length > 0) {
	            prefixFragment += '\n';
	        }
	    } else {
	        prefixVertex = [
	            generatePrecision(parameters),
	            '#define SHADER_TYPE ' + parameters.shaderType,
	            '#define SHADER_NAME ' + parameters.shaderName,
	            customDefines,
	            parameters.extensionClipCullDistance ? '#define USE_CLIP_DISTANCE' : '',
	            parameters.batching ? '#define USE_BATCHING' : '',
	            parameters.batchingColor ? '#define USE_BATCHING_COLOR' : '',
	            parameters.instancing ? '#define USE_INSTANCING' : '',
	            parameters.instancingColor ? '#define USE_INSTANCING_COLOR' : '',
	            parameters.instancingMorph ? '#define USE_INSTANCING_MORPH' : '',
	            parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
	            parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
	            parameters.map ? '#define USE_MAP' : '',
	            parameters.envMap ? '#define USE_ENVMAP' : '',
	            parameters.envMap ? '#define ' + envMapModeDefine : '',
	            parameters.lightMap ? '#define USE_LIGHTMAP' : '',
	            parameters.aoMap ? '#define USE_AOMAP' : '',
	            parameters.bumpMap ? '#define USE_BUMPMAP' : '',
	            parameters.normalMap ? '#define USE_NORMALMAP' : '',
	            parameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',
	            parameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',
	            parameters.displacementMap ? '#define USE_DISPLACEMENTMAP' : '',
	            parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
	            parameters.anisotropy ? '#define USE_ANISOTROPY' : '',
	            parameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',
	            parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
	            parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
	            parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
	            parameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',
	            parameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',
	            parameters.specularMap ? '#define USE_SPECULARMAP' : '',
	            parameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',
	            parameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',
	            parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
	            parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
	            parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
	            parameters.alphaHash ? '#define USE_ALPHAHASH' : '',
	            parameters.transmission ? '#define USE_TRANSMISSION' : '',
	            parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
	            parameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',
	            parameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',
	            parameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',
	            //
	            parameters.mapUv ? '#define MAP_UV ' + parameters.mapUv : '',
	            parameters.alphaMapUv ? '#define ALPHAMAP_UV ' + parameters.alphaMapUv : '',
	            parameters.lightMapUv ? '#define LIGHTMAP_UV ' + parameters.lightMapUv : '',
	            parameters.aoMapUv ? '#define AOMAP_UV ' + parameters.aoMapUv : '',
	            parameters.emissiveMapUv ? '#define EMISSIVEMAP_UV ' + parameters.emissiveMapUv : '',
	            parameters.bumpMapUv ? '#define BUMPMAP_UV ' + parameters.bumpMapUv : '',
	            parameters.normalMapUv ? '#define NORMALMAP_UV ' + parameters.normalMapUv : '',
	            parameters.displacementMapUv ? '#define DISPLACEMENTMAP_UV ' + parameters.displacementMapUv : '',
	            parameters.metalnessMapUv ? '#define METALNESSMAP_UV ' + parameters.metalnessMapUv : '',
	            parameters.roughnessMapUv ? '#define ROUGHNESSMAP_UV ' + parameters.roughnessMapUv : '',
	            parameters.anisotropyMapUv ? '#define ANISOTROPYMAP_UV ' + parameters.anisotropyMapUv : '',
	            parameters.clearcoatMapUv ? '#define CLEARCOATMAP_UV ' + parameters.clearcoatMapUv : '',
	            parameters.clearcoatNormalMapUv ? '#define CLEARCOAT_NORMALMAP_UV ' + parameters.clearcoatNormalMapUv : '',
	            parameters.clearcoatRoughnessMapUv ? '#define CLEARCOAT_ROUGHNESSMAP_UV ' + parameters.clearcoatRoughnessMapUv : '',
	            parameters.iridescenceMapUv ? '#define IRIDESCENCEMAP_UV ' + parameters.iridescenceMapUv : '',
	            parameters.iridescenceThicknessMapUv ? '#define IRIDESCENCE_THICKNESSMAP_UV ' + parameters.iridescenceThicknessMapUv : '',
	            parameters.sheenColorMapUv ? '#define SHEEN_COLORMAP_UV ' + parameters.sheenColorMapUv : '',
	            parameters.sheenRoughnessMapUv ? '#define SHEEN_ROUGHNESSMAP_UV ' + parameters.sheenRoughnessMapUv : '',
	            parameters.specularMapUv ? '#define SPECULARMAP_UV ' + parameters.specularMapUv : '',
	            parameters.specularColorMapUv ? '#define SPECULAR_COLORMAP_UV ' + parameters.specularColorMapUv : '',
	            parameters.specularIntensityMapUv ? '#define SPECULAR_INTENSITYMAP_UV ' + parameters.specularIntensityMapUv : '',
	            parameters.transmissionMapUv ? '#define TRANSMISSIONMAP_UV ' + parameters.transmissionMapUv : '',
	            parameters.thicknessMapUv ? '#define THICKNESSMAP_UV ' + parameters.thicknessMapUv : '',
	            //
	            parameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',
	            parameters.vertexColors ? '#define USE_COLOR' : '',
	            parameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',
	            parameters.vertexUv1s ? '#define USE_UV1' : '',
	            parameters.vertexUv2s ? '#define USE_UV2' : '',
	            parameters.vertexUv3s ? '#define USE_UV3' : '',
	            parameters.pointsUvs ? '#define USE_POINTS_UV' : '',
	            parameters.flatShading ? '#define FLAT_SHADED' : '',
	            parameters.skinning ? '#define USE_SKINNING' : '',
	            parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
	            parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',
	            parameters.morphColors ? '#define USE_MORPHCOLORS' : '',
	            parameters.morphTargetsCount > 0 ? '#define MORPHTARGETS_TEXTURE_STRIDE ' + parameters.morphTextureStride : '',
	            parameters.morphTargetsCount > 0 ? '#define MORPHTARGETS_COUNT ' + parameters.morphTargetsCount : '',
	            parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
	            parameters.flipSided ? '#define FLIP_SIDED' : '',
	            parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
	            parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
	            parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',
	            parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
	            parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
	            parameters.reverseDepthBuffer ? '#define USE_REVERSEDEPTHBUF' : '',
	            'uniform mat4 modelMatrix;',
	            'uniform mat4 modelViewMatrix;',
	            'uniform mat4 projectionMatrix;',
	            'uniform mat4 viewMatrix;',
	            'uniform mat3 normalMatrix;',
	            'uniform vec3 cameraPosition;',
	            'uniform bool isOrthographic;',
	            '#ifdef USE_INSTANCING',
	            '	attribute mat4 instanceMatrix;',
	            '#endif',
	            '#ifdef USE_INSTANCING_COLOR',
	            '	attribute vec3 instanceColor;',
	            '#endif',
	            '#ifdef USE_INSTANCING_MORPH',
	            '	uniform sampler2D morphTexture;',
	            '#endif',
	            'attribute vec3 position;',
	            'attribute vec3 normal;',
	            'attribute vec2 uv;',
	            '#ifdef USE_UV1',
	            '	attribute vec2 uv1;',
	            '#endif',
	            '#ifdef USE_UV2',
	            '	attribute vec2 uv2;',
	            '#endif',
	            '#ifdef USE_UV3',
	            '	attribute vec2 uv3;',
	            '#endif',
	            '#ifdef USE_TANGENT',
	            '	attribute vec4 tangent;',
	            '#endif',
	            '#if defined( USE_COLOR_ALPHA )',
	            '	attribute vec4 color;',
	            '#elif defined( USE_COLOR )',
	            '	attribute vec3 color;',
	            '#endif',
	            '#ifdef USE_SKINNING',
	            '	attribute vec4 skinIndex;',
	            '	attribute vec4 skinWeight;',
	            '#endif',
	            '\n'
	        ].filter(filterEmptyLine).join('\n');
	        prefixFragment = [
	            generatePrecision(parameters),
	            '#define SHADER_TYPE ' + parameters.shaderType,
	            '#define SHADER_NAME ' + parameters.shaderName,
	            customDefines,
	            parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
	            parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
	            parameters.alphaToCoverage ? '#define ALPHA_TO_COVERAGE' : '',
	            parameters.map ? '#define USE_MAP' : '',
	            parameters.matcap ? '#define USE_MATCAP' : '',
	            parameters.envMap ? '#define USE_ENVMAP' : '',
	            parameters.envMap ? '#define ' + envMapTypeDefine : '',
	            parameters.envMap ? '#define ' + envMapModeDefine : '',
	            parameters.envMap ? '#define ' + envMapBlendingDefine : '',
	            envMapCubeUVSize ? '#define CUBEUV_TEXEL_WIDTH ' + envMapCubeUVSize.texelWidth : '',
	            envMapCubeUVSize ? '#define CUBEUV_TEXEL_HEIGHT ' + envMapCubeUVSize.texelHeight : '',
	            envMapCubeUVSize ? '#define CUBEUV_MAX_MIP ' + envMapCubeUVSize.maxMip + '.0' : '',
	            parameters.lightMap ? '#define USE_LIGHTMAP' : '',
	            parameters.aoMap ? '#define USE_AOMAP' : '',
	            parameters.bumpMap ? '#define USE_BUMPMAP' : '',
	            parameters.normalMap ? '#define USE_NORMALMAP' : '',
	            parameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',
	            parameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',
	            parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
	            parameters.anisotropy ? '#define USE_ANISOTROPY' : '',
	            parameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',
	            parameters.clearcoat ? '#define USE_CLEARCOAT' : '',
	            parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
	            parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
	            parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
	            parameters.dispersion ? '#define USE_DISPERSION' : '',
	            parameters.iridescence ? '#define USE_IRIDESCENCE' : '',
	            parameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',
	            parameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',
	            parameters.specularMap ? '#define USE_SPECULARMAP' : '',
	            parameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',
	            parameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',
	            parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
	            parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
	            parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
	            parameters.alphaTest ? '#define USE_ALPHATEST' : '',
	            parameters.alphaHash ? '#define USE_ALPHAHASH' : '',
	            parameters.sheen ? '#define USE_SHEEN' : '',
	            parameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',
	            parameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',
	            parameters.transmission ? '#define USE_TRANSMISSION' : '',
	            parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
	            parameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',
	            parameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',
	            parameters.vertexColors || parameters.instancingColor || parameters.batchingColor ? '#define USE_COLOR' : '',
	            parameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',
	            parameters.vertexUv1s ? '#define USE_UV1' : '',
	            parameters.vertexUv2s ? '#define USE_UV2' : '',
	            parameters.vertexUv3s ? '#define USE_UV3' : '',
	            parameters.pointsUvs ? '#define USE_POINTS_UV' : '',
	            parameters.gradientMap ? '#define USE_GRADIENTMAP' : '',
	            parameters.flatShading ? '#define FLAT_SHADED' : '',
	            parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
	            parameters.flipSided ? '#define FLIP_SIDED' : '',
	            parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
	            parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
	            parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',
	            parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
	            parameters.decodeVideoTexture ? '#define DECODE_VIDEO_TEXTURE' : '',
	            parameters.decodeVideoTextureEmissive ? '#define DECODE_VIDEO_TEXTURE_EMISSIVE' : '',
	            parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
	            parameters.reverseDepthBuffer ? '#define USE_REVERSEDEPTHBUF' : '',
	            'uniform mat4 viewMatrix;',
	            'uniform vec3 cameraPosition;',
	            'uniform bool isOrthographic;',
	            parameters.toneMapping !== NoToneMapping ? '#define TONE_MAPPING' : '',
	            parameters.toneMapping !== NoToneMapping ? ShaderChunk['tonemapping_pars_fragment'] : '',
	            parameters.toneMapping !== NoToneMapping ? getToneMappingFunction('toneMapping', parameters.toneMapping) : '',
	            parameters.dithering ? '#define DITHERING' : '',
	            parameters.opaque ? '#define OPAQUE' : '',
	            ShaderChunk['colorspace_pars_fragment'],
	            getTexelEncodingFunction('linearToOutputTexel', parameters.outputColorSpace),
	            getLuminanceFunction(),
	            parameters.useDepthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',
	            '\n'
	        ].filter(filterEmptyLine).join('\n');
	    }
	    vertexShader = resolveIncludes(vertexShader);
	    vertexShader = replaceLightNums(vertexShader, parameters);
	    vertexShader = replaceClippingPlaneNums(vertexShader, parameters);
	    fragmentShader = resolveIncludes(fragmentShader);
	    fragmentShader = replaceLightNums(fragmentShader, parameters);
	    fragmentShader = replaceClippingPlaneNums(fragmentShader, parameters);
	    vertexShader = unrollLoops(vertexShader);
	    fragmentShader = unrollLoops(fragmentShader);
	    if (parameters.isRawShaderMaterial !== true) {
	        // GLSL 3.0 conversion for built-in materials and ShaderMaterial
	        versionString = '#version 300 es\n';
	        prefixVertex = [
	            customVertexExtensions,
	            '#define attribute in',
	            '#define varying out',
	            '#define texture2D texture'
	        ].join('\n') + '\n' + prefixVertex;
	        prefixFragment = [
	            '#define varying in',
	            parameters.glslVersion === GLSL3 ? '' : 'layout(location = 0) out highp vec4 pc_fragColor;',
	            parameters.glslVersion === GLSL3 ? '' : '#define gl_FragColor pc_fragColor',
	            '#define gl_FragDepthEXT gl_FragDepth',
	            '#define texture2D texture',
	            '#define textureCube texture',
	            '#define texture2DProj textureProj',
	            '#define texture2DLodEXT textureLod',
	            '#define texture2DProjLodEXT textureProjLod',
	            '#define textureCubeLodEXT textureLod',
	            '#define texture2DGradEXT textureGrad',
	            '#define texture2DProjGradEXT textureProjGrad',
	            '#define textureCubeGradEXT textureGrad'
	        ].join('\n') + '\n' + prefixFragment;
	    }
	    const vertexGlsl = versionString + prefixVertex + vertexShader;
	    const fragmentGlsl = versionString + prefixFragment + fragmentShader;
	    // console.log( '*VERTEX*', vertexGlsl );
	    // console.log( '*FRAGMENT*', fragmentGlsl );
	    const glVertexShader = WebGLShader(gl, gl.VERTEX_SHADER, vertexGlsl);
	    const glFragmentShader = WebGLShader(gl, gl.FRAGMENT_SHADER, fragmentGlsl);
	    gl.attachShader(program, glVertexShader);
	    gl.attachShader(program, glFragmentShader);
	    // Force a particular attribute to index 0.
	    if (parameters.index0AttributeName !== undefined) {
	        gl.bindAttribLocation(program, 0, parameters.index0AttributeName);
	    } else if (parameters.morphTargets === true) {
	        // programs with morphTargets displace position out of attribute 0
	        gl.bindAttribLocation(program, 0, 'position');
	    }
	    gl.linkProgram(program);
	    function onFirstUse(self1) {
	        // check for link errors
	        if (renderer.debug.checkShaderErrors) {
	            const programLog = gl.getProgramInfoLog(program).trim();
	            const vertexLog = gl.getShaderInfoLog(glVertexShader).trim();
	            const fragmentLog = gl.getShaderInfoLog(glFragmentShader).trim();
	            let runnable = true;
	            let haveDiagnostics = true;
	            if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {
	                runnable = false;
	                if (typeof renderer.debug.onShaderError === 'function') {
	                    renderer.debug.onShaderError(gl, program, glVertexShader, glFragmentShader);
	                } else {
	                    // default error reporting
	                    const vertexErrors = getShaderErrors(gl, glVertexShader, 'vertex');
	                    const fragmentErrors = getShaderErrors(gl, glFragmentShader, 'fragment');
	                    console.error('THREE.WebGLProgram: Shader Error ' + gl.getError() + ' - ' + 'VALIDATE_STATUS ' + gl.getProgramParameter(program, gl.VALIDATE_STATUS) + '\n\n' + 'Material Name: ' + self1.name + '\n' + 'Material Type: ' + self1.type + '\n\n' + 'Program Info Log: ' + programLog + '\n' + vertexErrors + '\n' + fragmentErrors);
	                }
	            } else if (programLog !== '') {
	                console.warn('THREE.WebGLProgram: Program Info Log:', programLog);
	            } else if (vertexLog === '' || fragmentLog === '') {
	                haveDiagnostics = false;
	            }
	            if (haveDiagnostics) {
	                self1.diagnostics = {
	                    runnable: runnable,
	                    programLog: programLog,
	                    vertexShader: {
	                        log: vertexLog,
	                        prefix: prefixVertex
	                    },
	                    fragmentShader: {
	                        log: fragmentLog,
	                        prefix: prefixFragment
	                    }
	                };
	            }
	        }
	        // Clean up
	        // Crashes in iOS9 and iOS10. #18402
	        // gl.detachShader( program, glVertexShader );
	        // gl.detachShader( program, glFragmentShader );
	        gl.deleteShader(glVertexShader);
	        gl.deleteShader(glFragmentShader);
	        cachedUniforms = new WebGLUniforms(gl, program);
	        cachedAttributes = fetchAttributeLocations(gl, program);
	    }
	    // set up caching for uniform locations
	    let cachedUniforms;
	    this.getUniforms = function() {
	        if (cachedUniforms === undefined) {
	            // Populates cachedUniforms and cachedAttributes
	            onFirstUse(this);
	        }
	        return cachedUniforms;
	    };
	    // set up caching for attribute locations
	    let cachedAttributes;
	    this.getAttributes = function() {
	        if (cachedAttributes === undefined) {
	            // Populates cachedAttributes and cachedUniforms
	            onFirstUse(this);
	        }
	        return cachedAttributes;
	    };
	    // indicate when the program is ready to be used. if the KHR_parallel_shader_compile extension isn't supported,
	    // flag the program as ready immediately. It may cause a stall when it's first used.
	    let programReady = parameters.rendererExtensionParallelShaderCompile === false;
	    this.isReady = function() {
	        if (programReady === false) {
	            programReady = gl.getProgramParameter(program, COMPLETION_STATUS_KHR);
	        }
	        return programReady;
	    };
	    // free resource
	    this.destroy = function() {
	        bindingStates.releaseStatesOfProgram(this);
	        gl.deleteProgram(program);
	        this.program = undefined;
	    };
	    //
	    this.type = parameters.shaderType;
	    this.name = parameters.shaderName;
	    this.id = programIdCount++;
	    this.cacheKey = cacheKey;
	    this.usedTimes = 1;
	    this.program = program;
	    this.vertexShader = glVertexShader;
	    this.fragmentShader = glFragmentShader;
	    return this;
	}
	let _id = 0;
	class WebGLShaderCache {
	    update(material) {
	        const vertexShader = material.vertexShader;
	        const fragmentShader = material.fragmentShader;
	        const vertexShaderStage = this._getShaderStage(vertexShader);
	        const fragmentShaderStage = this._getShaderStage(fragmentShader);
	        const materialShaders = this._getShaderCacheForMaterial(material);
	        if (materialShaders.has(vertexShaderStage) === false) {
	            materialShaders.add(vertexShaderStage);
	            vertexShaderStage.usedTimes++;
	        }
	        if (materialShaders.has(fragmentShaderStage) === false) {
	            materialShaders.add(fragmentShaderStage);
	            fragmentShaderStage.usedTimes++;
	        }
	        return this;
	    }
	    remove(material) {
	        const materialShaders = this.materialCache.get(material);
	        for (const shaderStage of materialShaders){
	            shaderStage.usedTimes--;
	            if (shaderStage.usedTimes === 0) this.shaderCache.delete(shaderStage.code);
	        }
	        this.materialCache.delete(material);
	        return this;
	    }
	    getVertexShaderID(material) {
	        return this._getShaderStage(material.vertexShader).id;
	    }
	    getFragmentShaderID(material) {
	        return this._getShaderStage(material.fragmentShader).id;
	    }
	    dispose() {
	        this.shaderCache.clear();
	        this.materialCache.clear();
	    }
	    _getShaderCacheForMaterial(material) {
	        const cache = this.materialCache;
	        let set = cache.get(material);
	        if (set === undefined) {
	            set = new Set();
	            cache.set(material, set);
	        }
	        return set;
	    }
	    _getShaderStage(code) {
	        const cache = this.shaderCache;
	        let stage = cache.get(code);
	        if (stage === undefined) {
	            stage = new WebGLShaderStage(code);
	            cache.set(code, stage);
	        }
	        return stage;
	    }
	    constructor(){
	        this.shaderCache = new Map();
	        this.materialCache = new Map();
	    }
	}
	class WebGLShaderStage {
	    constructor(code){
	        this.id = _id++;
	        this.code = code;
	        this.usedTimes = 0;
	    }
	}
	function WebGLPrograms(renderer, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping) {
	    const _programLayers = new Layers();
	    const _customShaders = new WebGLShaderCache();
	    const _activeChannels = new Set();
	    const programs = [];
	    const logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;
	    const SUPPORTS_VERTEX_TEXTURES = capabilities.vertexTextures;
	    let precision = capabilities.precision;
	    const shaderIDs = {
	        MeshDepthMaterial: 'depth',
	        MeshDistanceMaterial: 'distanceRGBA',
	        MeshNormalMaterial: 'normal',
	        MeshBasicMaterial: 'basic',
	        MeshLambertMaterial: 'lambert',
	        MeshPhongMaterial: 'phong',
	        MeshToonMaterial: 'toon',
	        MeshStandardMaterial: 'physical',
	        MeshPhysicalMaterial: 'physical',
	        MeshMatcapMaterial: 'matcap',
	        LineBasicMaterial: 'basic',
	        LineDashedMaterial: 'dashed',
	        PointsMaterial: 'points',
	        ShadowMaterial: 'shadow',
	        SpriteMaterial: 'sprite'
	    };
	    function getChannel(value) {
	        _activeChannels.add(value);
	        if (value === 0) return 'uv';
	        return `uv${value}`;
	    }
	    function getParameters(material, lights, shadows, scene, object) {
	        const fog = scene.fog;
	        const geometry = object.geometry;
	        const environment = material.isMeshStandardMaterial ? scene.environment : null;
	        const envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || environment);
	        const envMapCubeUVHeight = !!envMap && envMap.mapping === CubeUVReflectionMapping ? envMap.image.height : null;
	        const shaderID = shaderIDs[material.type];
	        // heuristics to create shader parameters according to lights in the scene
	        // (not to blow over maxLights budget)
	        if (material.precision !== null) {
	            precision = capabilities.getMaxPrecision(material.precision);
	            if (precision !== material.precision) {
	                console.warn('THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.');
	            }
	        }
	        //
	        const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
	        const morphTargetsCount = morphAttribute !== undefined ? morphAttribute.length : 0;
	        let morphTextureStride = 0;
	        if (geometry.morphAttributes.position !== undefined) morphTextureStride = 1;
	        if (geometry.morphAttributes.normal !== undefined) morphTextureStride = 2;
	        if (geometry.morphAttributes.color !== undefined) morphTextureStride = 3;
	        //
	        let vertexShader, fragmentShader;
	        let customVertexShaderID, customFragmentShaderID;
	        if (shaderID) {
	            const shader = ShaderLib[shaderID];
	            vertexShader = shader.vertexShader;
	            fragmentShader = shader.fragmentShader;
	        } else {
	            vertexShader = material.vertexShader;
	            fragmentShader = material.fragmentShader;
	            _customShaders.update(material);
	            customVertexShaderID = _customShaders.getVertexShaderID(material);
	            customFragmentShaderID = _customShaders.getFragmentShaderID(material);
	        }
	        const currentRenderTarget = renderer.getRenderTarget();
	        const reverseDepthBuffer = renderer.state.buffers.depth.getReversed();
	        const IS_INSTANCEDMESH = object.isInstancedMesh === true;
	        const IS_BATCHEDMESH = object.isBatchedMesh === true;
	        const HAS_MAP = !!material.map;
	        const HAS_MATCAP = !!material.matcap;
	        const HAS_ENVMAP = !!envMap;
	        const HAS_AOMAP = !!material.aoMap;
	        const HAS_LIGHTMAP = !!material.lightMap;
	        const HAS_BUMPMAP = !!material.bumpMap;
	        const HAS_NORMALMAP = !!material.normalMap;
	        const HAS_DISPLACEMENTMAP = !!material.displacementMap;
	        const HAS_EMISSIVEMAP = !!material.emissiveMap;
	        const HAS_METALNESSMAP = !!material.metalnessMap;
	        const HAS_ROUGHNESSMAP = !!material.roughnessMap;
	        const HAS_ANISOTROPY = material.anisotropy > 0;
	        const HAS_CLEARCOAT = material.clearcoat > 0;
	        const HAS_DISPERSION = material.dispersion > 0;
	        const HAS_IRIDESCENCE = material.iridescence > 0;
	        const HAS_SHEEN = material.sheen > 0;
	        const HAS_TRANSMISSION = material.transmission > 0;
	        const HAS_ANISOTROPYMAP = HAS_ANISOTROPY && !!material.anisotropyMap;
	        const HAS_CLEARCOATMAP = HAS_CLEARCOAT && !!material.clearcoatMap;
	        const HAS_CLEARCOAT_NORMALMAP = HAS_CLEARCOAT && !!material.clearcoatNormalMap;
	        const HAS_CLEARCOAT_ROUGHNESSMAP = HAS_CLEARCOAT && !!material.clearcoatRoughnessMap;
	        const HAS_IRIDESCENCEMAP = HAS_IRIDESCENCE && !!material.iridescenceMap;
	        const HAS_IRIDESCENCE_THICKNESSMAP = HAS_IRIDESCENCE && !!material.iridescenceThicknessMap;
	        const HAS_SHEEN_COLORMAP = HAS_SHEEN && !!material.sheenColorMap;
	        const HAS_SHEEN_ROUGHNESSMAP = HAS_SHEEN && !!material.sheenRoughnessMap;
	        const HAS_SPECULARMAP = !!material.specularMap;
	        const HAS_SPECULAR_COLORMAP = !!material.specularColorMap;
	        const HAS_SPECULAR_INTENSITYMAP = !!material.specularIntensityMap;
	        const HAS_TRANSMISSIONMAP = HAS_TRANSMISSION && !!material.transmissionMap;
	        const HAS_THICKNESSMAP = HAS_TRANSMISSION && !!material.thicknessMap;
	        const HAS_GRADIENTMAP = !!material.gradientMap;
	        const HAS_ALPHAMAP = !!material.alphaMap;
	        const HAS_ALPHATEST = material.alphaTest > 0;
	        const HAS_ALPHAHASH = !!material.alphaHash;
	        const HAS_EXTENSIONS = !!material.extensions;
	        let toneMapping = NoToneMapping;
	        if (material.toneMapped) {
	            if (currentRenderTarget === null || currentRenderTarget.isXRRenderTarget === true) {
	                toneMapping = renderer.toneMapping;
	            }
	        }
	        const parameters = {
	            shaderID: shaderID,
	            shaderType: material.type,
	            shaderName: material.name,
	            vertexShader: vertexShader,
	            fragmentShader: fragmentShader,
	            defines: material.defines,
	            customVertexShaderID: customVertexShaderID,
	            customFragmentShaderID: customFragmentShaderID,
	            isRawShaderMaterial: material.isRawShaderMaterial === true,
	            glslVersion: material.glslVersion,
	            precision: precision,
	            batching: IS_BATCHEDMESH,
	            batchingColor: IS_BATCHEDMESH && object._colorsTexture !== null,
	            instancing: IS_INSTANCEDMESH,
	            instancingColor: IS_INSTANCEDMESH && object.instanceColor !== null,
	            instancingMorph: IS_INSTANCEDMESH && object.morphTexture !== null,
	            supportsVertexTextures: SUPPORTS_VERTEX_TEXTURES,
	            outputColorSpace: currentRenderTarget === null ? renderer.outputColorSpace : currentRenderTarget.isXRRenderTarget === true ? currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace,
	            alphaToCoverage: !!material.alphaToCoverage,
	            map: HAS_MAP,
	            matcap: HAS_MATCAP,
	            envMap: HAS_ENVMAP,
	            envMapMode: HAS_ENVMAP && envMap.mapping,
	            envMapCubeUVHeight: envMapCubeUVHeight,
	            aoMap: HAS_AOMAP,
	            lightMap: HAS_LIGHTMAP,
	            bumpMap: HAS_BUMPMAP,
	            normalMap: HAS_NORMALMAP,
	            displacementMap: SUPPORTS_VERTEX_TEXTURES && HAS_DISPLACEMENTMAP,
	            emissiveMap: HAS_EMISSIVEMAP,
	            normalMapObjectSpace: HAS_NORMALMAP && material.normalMapType === ObjectSpaceNormalMap,
	            normalMapTangentSpace: HAS_NORMALMAP && material.normalMapType === TangentSpaceNormalMap,
	            metalnessMap: HAS_METALNESSMAP,
	            roughnessMap: HAS_ROUGHNESSMAP,
	            anisotropy: HAS_ANISOTROPY,
	            anisotropyMap: HAS_ANISOTROPYMAP,
	            clearcoat: HAS_CLEARCOAT,
	            clearcoatMap: HAS_CLEARCOATMAP,
	            clearcoatNormalMap: HAS_CLEARCOAT_NORMALMAP,
	            clearcoatRoughnessMap: HAS_CLEARCOAT_ROUGHNESSMAP,
	            dispersion: HAS_DISPERSION,
	            iridescence: HAS_IRIDESCENCE,
	            iridescenceMap: HAS_IRIDESCENCEMAP,
	            iridescenceThicknessMap: HAS_IRIDESCENCE_THICKNESSMAP,
	            sheen: HAS_SHEEN,
	            sheenColorMap: HAS_SHEEN_COLORMAP,
	            sheenRoughnessMap: HAS_SHEEN_ROUGHNESSMAP,
	            specularMap: HAS_SPECULARMAP,
	            specularColorMap: HAS_SPECULAR_COLORMAP,
	            specularIntensityMap: HAS_SPECULAR_INTENSITYMAP,
	            transmission: HAS_TRANSMISSION,
	            transmissionMap: HAS_TRANSMISSIONMAP,
	            thicknessMap: HAS_THICKNESSMAP,
	            gradientMap: HAS_GRADIENTMAP,
	            opaque: material.transparent === false && material.blending === NormalBlending && material.alphaToCoverage === false,
	            alphaMap: HAS_ALPHAMAP,
	            alphaTest: HAS_ALPHATEST,
	            alphaHash: HAS_ALPHAHASH,
	            combine: material.combine,
	            //
	            mapUv: HAS_MAP && getChannel(material.map.channel),
	            aoMapUv: HAS_AOMAP && getChannel(material.aoMap.channel),
	            lightMapUv: HAS_LIGHTMAP && getChannel(material.lightMap.channel),
	            bumpMapUv: HAS_BUMPMAP && getChannel(material.bumpMap.channel),
	            normalMapUv: HAS_NORMALMAP && getChannel(material.normalMap.channel),
	            displacementMapUv: HAS_DISPLACEMENTMAP && getChannel(material.displacementMap.channel),
	            emissiveMapUv: HAS_EMISSIVEMAP && getChannel(material.emissiveMap.channel),
	            metalnessMapUv: HAS_METALNESSMAP && getChannel(material.metalnessMap.channel),
	            roughnessMapUv: HAS_ROUGHNESSMAP && getChannel(material.roughnessMap.channel),
	            anisotropyMapUv: HAS_ANISOTROPYMAP && getChannel(material.anisotropyMap.channel),
	            clearcoatMapUv: HAS_CLEARCOATMAP && getChannel(material.clearcoatMap.channel),
	            clearcoatNormalMapUv: HAS_CLEARCOAT_NORMALMAP && getChannel(material.clearcoatNormalMap.channel),
	            clearcoatRoughnessMapUv: HAS_CLEARCOAT_ROUGHNESSMAP && getChannel(material.clearcoatRoughnessMap.channel),
	            iridescenceMapUv: HAS_IRIDESCENCEMAP && getChannel(material.iridescenceMap.channel),
	            iridescenceThicknessMapUv: HAS_IRIDESCENCE_THICKNESSMAP && getChannel(material.iridescenceThicknessMap.channel),
	            sheenColorMapUv: HAS_SHEEN_COLORMAP && getChannel(material.sheenColorMap.channel),
	            sheenRoughnessMapUv: HAS_SHEEN_ROUGHNESSMAP && getChannel(material.sheenRoughnessMap.channel),
	            specularMapUv: HAS_SPECULARMAP && getChannel(material.specularMap.channel),
	            specularColorMapUv: HAS_SPECULAR_COLORMAP && getChannel(material.specularColorMap.channel),
	            specularIntensityMapUv: HAS_SPECULAR_INTENSITYMAP && getChannel(material.specularIntensityMap.channel),
	            transmissionMapUv: HAS_TRANSMISSIONMAP && getChannel(material.transmissionMap.channel),
	            thicknessMapUv: HAS_THICKNESSMAP && getChannel(material.thicknessMap.channel),
	            alphaMapUv: HAS_ALPHAMAP && getChannel(material.alphaMap.channel),
	            //
	            vertexTangents: !!geometry.attributes.tangent && (HAS_NORMALMAP || HAS_ANISOTROPY),
	            vertexColors: material.vertexColors,
	            vertexAlphas: material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4,
	            pointsUvs: object.isPoints === true && !!geometry.attributes.uv && (HAS_MAP || HAS_ALPHAMAP),
	            fog: !!fog,
	            useFog: material.fog === true,
	            fogExp2: !!fog && fog.isFogExp2,
	            flatShading: material.flatShading === true,
	            sizeAttenuation: material.sizeAttenuation === true,
	            logarithmicDepthBuffer: logarithmicDepthBuffer,
	            reverseDepthBuffer: reverseDepthBuffer,
	            skinning: object.isSkinnedMesh === true,
	            morphTargets: geometry.morphAttributes.position !== undefined,
	            morphNormals: geometry.morphAttributes.normal !== undefined,
	            morphColors: geometry.morphAttributes.color !== undefined,
	            morphTargetsCount: morphTargetsCount,
	            morphTextureStride: morphTextureStride,
	            numDirLights: lights.directional.length,
	            numPointLights: lights.point.length,
	            numSpotLights: lights.spot.length,
	            numSpotLightMaps: lights.spotLightMap.length,
	            numRectAreaLights: lights.rectArea.length,
	            numHemiLights: lights.hemi.length,
	            numDirLightShadows: lights.directionalShadowMap.length,
	            numPointLightShadows: lights.pointShadowMap.length,
	            numSpotLightShadows: lights.spotShadowMap.length,
	            numSpotLightShadowsWithMaps: lights.numSpotLightShadowsWithMaps,
	            numLightProbes: lights.numLightProbes,
	            numClippingPlanes: clipping.numPlanes,
	            numClipIntersection: clipping.numIntersection,
	            dithering: material.dithering,
	            shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,
	            shadowMapType: renderer.shadowMap.type,
	            toneMapping: toneMapping,
	            decodeVideoTexture: HAS_MAP && material.map.isVideoTexture === true && ColorManagement.getTransfer(material.map.colorSpace) === SRGBTransfer,
	            decodeVideoTextureEmissive: HAS_EMISSIVEMAP && material.emissiveMap.isVideoTexture === true && ColorManagement.getTransfer(material.emissiveMap.colorSpace) === SRGBTransfer,
	            premultipliedAlpha: material.premultipliedAlpha,
	            doubleSided: material.side === DoubleSide,
	            flipSided: material.side === BackSide,
	            useDepthPacking: material.depthPacking >= 0,
	            depthPacking: material.depthPacking || 0,
	            index0AttributeName: material.index0AttributeName,
	            extensionClipCullDistance: HAS_EXTENSIONS && material.extensions.clipCullDistance === true && extensions.has('WEBGL_clip_cull_distance'),
	            extensionMultiDraw: (HAS_EXTENSIONS && material.extensions.multiDraw === true || IS_BATCHEDMESH) && extensions.has('WEBGL_multi_draw'),
	            rendererExtensionParallelShaderCompile: extensions.has('KHR_parallel_shader_compile'),
	            customProgramCacheKey: material.customProgramCacheKey()
	        };
	        // the usage of getChannel() determines the active texture channels for this shader
	        parameters.vertexUv1s = _activeChannels.has(1);
	        parameters.vertexUv2s = _activeChannels.has(2);
	        parameters.vertexUv3s = _activeChannels.has(3);
	        _activeChannels.clear();
	        return parameters;
	    }
	    function getProgramCacheKey(parameters) {
	        const array = [];
	        if (parameters.shaderID) {
	            array.push(parameters.shaderID);
	        } else {
	            array.push(parameters.customVertexShaderID);
	            array.push(parameters.customFragmentShaderID);
	        }
	        if (parameters.defines !== undefined) {
	            for(const name in parameters.defines){
	                array.push(name);
	                array.push(parameters.defines[name]);
	            }
	        }
	        if (parameters.isRawShaderMaterial === false) {
	            getProgramCacheKeyParameters(array, parameters);
	            getProgramCacheKeyBooleans(array, parameters);
	            array.push(renderer.outputColorSpace);
	        }
	        array.push(parameters.customProgramCacheKey);
	        return array.join();
	    }
	    function getProgramCacheKeyParameters(array, parameters) {
	        array.push(parameters.precision);
	        array.push(parameters.outputColorSpace);
	        array.push(parameters.envMapMode);
	        array.push(parameters.envMapCubeUVHeight);
	        array.push(parameters.mapUv);
	        array.push(parameters.alphaMapUv);
	        array.push(parameters.lightMapUv);
	        array.push(parameters.aoMapUv);
	        array.push(parameters.bumpMapUv);
	        array.push(parameters.normalMapUv);
	        array.push(parameters.displacementMapUv);
	        array.push(parameters.emissiveMapUv);
	        array.push(parameters.metalnessMapUv);
	        array.push(parameters.roughnessMapUv);
	        array.push(parameters.anisotropyMapUv);
	        array.push(parameters.clearcoatMapUv);
	        array.push(parameters.clearcoatNormalMapUv);
	        array.push(parameters.clearcoatRoughnessMapUv);
	        array.push(parameters.iridescenceMapUv);
	        array.push(parameters.iridescenceThicknessMapUv);
	        array.push(parameters.sheenColorMapUv);
	        array.push(parameters.sheenRoughnessMapUv);
	        array.push(parameters.specularMapUv);
	        array.push(parameters.specularColorMapUv);
	        array.push(parameters.specularIntensityMapUv);
	        array.push(parameters.transmissionMapUv);
	        array.push(parameters.thicknessMapUv);
	        array.push(parameters.combine);
	        array.push(parameters.fogExp2);
	        array.push(parameters.sizeAttenuation);
	        array.push(parameters.morphTargetsCount);
	        array.push(parameters.morphAttributeCount);
	        array.push(parameters.numDirLights);
	        array.push(parameters.numPointLights);
	        array.push(parameters.numSpotLights);
	        array.push(parameters.numSpotLightMaps);
	        array.push(parameters.numHemiLights);
	        array.push(parameters.numRectAreaLights);
	        array.push(parameters.numDirLightShadows);
	        array.push(parameters.numPointLightShadows);
	        array.push(parameters.numSpotLightShadows);
	        array.push(parameters.numSpotLightShadowsWithMaps);
	        array.push(parameters.numLightProbes);
	        array.push(parameters.shadowMapType);
	        array.push(parameters.toneMapping);
	        array.push(parameters.numClippingPlanes);
	        array.push(parameters.numClipIntersection);
	        array.push(parameters.depthPacking);
	    }
	    function getProgramCacheKeyBooleans(array, parameters) {
	        _programLayers.disableAll();
	        if (parameters.supportsVertexTextures) _programLayers.enable(0);
	        if (parameters.instancing) _programLayers.enable(1);
	        if (parameters.instancingColor) _programLayers.enable(2);
	        if (parameters.instancingMorph) _programLayers.enable(3);
	        if (parameters.matcap) _programLayers.enable(4);
	        if (parameters.envMap) _programLayers.enable(5);
	        if (parameters.normalMapObjectSpace) _programLayers.enable(6);
	        if (parameters.normalMapTangentSpace) _programLayers.enable(7);
	        if (parameters.clearcoat) _programLayers.enable(8);
	        if (parameters.iridescence) _programLayers.enable(9);
	        if (parameters.alphaTest) _programLayers.enable(10);
	        if (parameters.vertexColors) _programLayers.enable(11);
	        if (parameters.vertexAlphas) _programLayers.enable(12);
	        if (parameters.vertexUv1s) _programLayers.enable(13);
	        if (parameters.vertexUv2s) _programLayers.enable(14);
	        if (parameters.vertexUv3s) _programLayers.enable(15);
	        if (parameters.vertexTangents) _programLayers.enable(16);
	        if (parameters.anisotropy) _programLayers.enable(17);
	        if (parameters.alphaHash) _programLayers.enable(18);
	        if (parameters.batching) _programLayers.enable(19);
	        if (parameters.dispersion) _programLayers.enable(20);
	        if (parameters.batchingColor) _programLayers.enable(21);
	        array.push(_programLayers.mask);
	        _programLayers.disableAll();
	        if (parameters.fog) _programLayers.enable(0);
	        if (parameters.useFog) _programLayers.enable(1);
	        if (parameters.flatShading) _programLayers.enable(2);
	        if (parameters.logarithmicDepthBuffer) _programLayers.enable(3);
	        if (parameters.reverseDepthBuffer) _programLayers.enable(4);
	        if (parameters.skinning) _programLayers.enable(5);
	        if (parameters.morphTargets) _programLayers.enable(6);
	        if (parameters.morphNormals) _programLayers.enable(7);
	        if (parameters.morphColors) _programLayers.enable(8);
	        if (parameters.premultipliedAlpha) _programLayers.enable(9);
	        if (parameters.shadowMapEnabled) _programLayers.enable(10);
	        if (parameters.doubleSided) _programLayers.enable(11);
	        if (parameters.flipSided) _programLayers.enable(12);
	        if (parameters.useDepthPacking) _programLayers.enable(13);
	        if (parameters.dithering) _programLayers.enable(14);
	        if (parameters.transmission) _programLayers.enable(15);
	        if (parameters.sheen) _programLayers.enable(16);
	        if (parameters.opaque) _programLayers.enable(17);
	        if (parameters.pointsUvs) _programLayers.enable(18);
	        if (parameters.decodeVideoTexture) _programLayers.enable(19);
	        if (parameters.decodeVideoTextureEmissive) _programLayers.enable(20);
	        if (parameters.alphaToCoverage) _programLayers.enable(21);
	        array.push(_programLayers.mask);
	    }
	    function getUniforms(material) {
	        const shaderID = shaderIDs[material.type];
	        let uniforms;
	        if (shaderID) {
	            const shader = ShaderLib[shaderID];
	            uniforms = UniformsUtils.clone(shader.uniforms);
	        } else {
	            uniforms = material.uniforms;
	        }
	        return uniforms;
	    }
	    function acquireProgram(parameters, cacheKey) {
	        let program;
	        // Check if code has been already compiled
	        for(let p = 0, pl = programs.length; p < pl; p++){
	            const preexistingProgram = programs[p];
	            if (preexistingProgram.cacheKey === cacheKey) {
	                program = preexistingProgram;
	                ++program.usedTimes;
	                break;
	            }
	        }
	        if (program === undefined) {
	            program = new WebGLProgram(renderer, cacheKey, parameters, bindingStates);
	            programs.push(program);
	        }
	        return program;
	    }
	    function releaseProgram(program) {
	        if (--program.usedTimes === 0) {
	            // Remove from unordered set
	            const i = programs.indexOf(program);
	            programs[i] = programs[programs.length - 1];
	            programs.pop();
	            // Free WebGL resources
	            program.destroy();
	        }
	    }
	    function releaseShaderCache(material) {
	        _customShaders.remove(material);
	    }
	    function dispose() {
	        _customShaders.dispose();
	    }
	    return {
	        getParameters: getParameters,
	        getProgramCacheKey: getProgramCacheKey,
	        getUniforms: getUniforms,
	        acquireProgram: acquireProgram,
	        releaseProgram: releaseProgram,
	        releaseShaderCache: releaseShaderCache,
	        // Exposed for resource monitoring & error feedback via renderer.info:
	        programs: programs,
	        dispose: dispose
	    };
	}
	function WebGLProperties() {
	    let properties = new WeakMap();
	    function has(object) {
	        return properties.has(object);
	    }
	    function get(object) {
	        let map = properties.get(object);
	        if (map === undefined) {
	            map = {};
	            properties.set(object, map);
	        }
	        return map;
	    }
	    function remove(object) {
	        properties.delete(object);
	    }
	    function update(object, key, value) {
	        properties.get(object)[key] = value;
	    }
	    function dispose() {
	        properties = new WeakMap();
	    }
	    return {
	        has: has,
	        get: get,
	        remove: remove,
	        update: update,
	        dispose: dispose
	    };
	}
	function painterSortStable(a, b) {
	    if (a.groupOrder !== b.groupOrder) {
	        return a.groupOrder - b.groupOrder;
	    } else if (a.renderOrder !== b.renderOrder) {
	        return a.renderOrder - b.renderOrder;
	    } else if (a.material.id !== b.material.id) {
	        return a.material.id - b.material.id;
	    } else if (a.z !== b.z) {
	        return a.z - b.z;
	    } else {
	        return a.id - b.id;
	    }
	}
	function reversePainterSortStable(a, b) {
	    if (a.groupOrder !== b.groupOrder) {
	        return a.groupOrder - b.groupOrder;
	    } else if (a.renderOrder !== b.renderOrder) {
	        return a.renderOrder - b.renderOrder;
	    } else if (a.z !== b.z) {
	        return b.z - a.z;
	    } else {
	        return a.id - b.id;
	    }
	}
	function WebGLRenderList() {
	    const renderItems = [];
	    let renderItemsIndex = 0;
	    const opaque = [];
	    const transmissive = [];
	    const transparent = [];
	    function init() {
	        renderItemsIndex = 0;
	        opaque.length = 0;
	        transmissive.length = 0;
	        transparent.length = 0;
	    }
	    function getNextRenderItem(object, geometry, material, groupOrder, z, group) {
	        let renderItem = renderItems[renderItemsIndex];
	        if (renderItem === undefined) {
	            renderItem = {
	                id: object.id,
	                object: object,
	                geometry: geometry,
	                material: material,
	                groupOrder: groupOrder,
	                renderOrder: object.renderOrder,
	                z: z,
	                group: group
	            };
	            renderItems[renderItemsIndex] = renderItem;
	        } else {
	            renderItem.id = object.id;
	            renderItem.object = object;
	            renderItem.geometry = geometry;
	            renderItem.material = material;
	            renderItem.groupOrder = groupOrder;
	            renderItem.renderOrder = object.renderOrder;
	            renderItem.z = z;
	            renderItem.group = group;
	        }
	        renderItemsIndex++;
	        return renderItem;
	    }
	    function push(object, geometry, material, groupOrder, z, group) {
	        const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group);
	        if (material.transmission > 0.0) {
	            transmissive.push(renderItem);
	        } else if (material.transparent === true) {
	            transparent.push(renderItem);
	        } else {
	            opaque.push(renderItem);
	        }
	    }
	    function unshift(object, geometry, material, groupOrder, z, group) {
	        const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group);
	        if (material.transmission > 0.0) {
	            transmissive.unshift(renderItem);
	        } else if (material.transparent === true) {
	            transparent.unshift(renderItem);
	        } else {
	            opaque.unshift(renderItem);
	        }
	    }
	    function sort(customOpaqueSort, customTransparentSort) {
	        if (opaque.length > 1) opaque.sort(customOpaqueSort || painterSortStable);
	        if (transmissive.length > 1) transmissive.sort(customTransparentSort || reversePainterSortStable);
	        if (transparent.length > 1) transparent.sort(customTransparentSort || reversePainterSortStable);
	    }
	    function finish() {
	        // Clear references from inactive renderItems in the list
	        for(let i = renderItemsIndex, il = renderItems.length; i < il; i++){
	            const renderItem = renderItems[i];
	            if (renderItem.id === null) break;
	            renderItem.id = null;
	            renderItem.object = null;
	            renderItem.geometry = null;
	            renderItem.material = null;
	            renderItem.group = null;
	        }
	    }
	    return {
	        opaque: opaque,
	        transmissive: transmissive,
	        transparent: transparent,
	        init: init,
	        push: push,
	        unshift: unshift,
	        finish: finish,
	        sort: sort
	    };
	}
	function WebGLRenderLists() {
	    let lists = new WeakMap();
	    function get(scene, renderCallDepth) {
	        const listArray = lists.get(scene);
	        let list;
	        if (listArray === undefined) {
	            list = new WebGLRenderList();
	            lists.set(scene, [
	                list
	            ]);
	        } else {
	            if (renderCallDepth >= listArray.length) {
	                list = new WebGLRenderList();
	                listArray.push(list);
	            } else {
	                list = listArray[renderCallDepth];
	            }
	        }
	        return list;
	    }
	    function dispose() {
	        lists = new WeakMap();
	    }
	    return {
	        get: get,
	        dispose: dispose
	    };
	}
	function UniformsCache() {
	    const lights = {};
	    return {
	        get: function(light) {
	            if (lights[light.id] !== undefined) {
	                return lights[light.id];
	            }
	            let uniforms;
	            switch(light.type){
	                case 'DirectionalLight':
	                    uniforms = {
	                        direction: new Vector3(),
	                        color: new Color()
	                    };
	                    break;
	                case 'SpotLight':
	                    uniforms = {
	                        position: new Vector3(),
	                        direction: new Vector3(),
	                        color: new Color(),
	                        distance: 0,
	                        coneCos: 0,
	                        penumbraCos: 0,
	                        decay: 0
	                    };
	                    break;
	                case 'PointLight':
	                    uniforms = {
	                        position: new Vector3(),
	                        color: new Color(),
	                        distance: 0,
	                        decay: 0
	                    };
	                    break;
	                case 'HemisphereLight':
	                    uniforms = {
	                        direction: new Vector3(),
	                        skyColor: new Color(),
	                        groundColor: new Color()
	                    };
	                    break;
	                case 'RectAreaLight':
	                    uniforms = {
	                        color: new Color(),
	                        position: new Vector3(),
	                        halfWidth: new Vector3(),
	                        halfHeight: new Vector3()
	                    };
	                    break;
	            }
	            lights[light.id] = uniforms;
	            return uniforms;
	        }
	    };
	}
	function ShadowUniformsCache() {
	    const lights = {};
	    return {
	        get: function(light) {
	            if (lights[light.id] !== undefined) {
	                return lights[light.id];
	            }
	            let uniforms;
	            switch(light.type){
	                case 'DirectionalLight':
	                    uniforms = {
	                        shadowIntensity: 1,
	                        shadowBias: 0,
	                        shadowNormalBias: 0,
	                        shadowRadius: 1,
	                        shadowMapSize: new Vector2()
	                    };
	                    break;
	                case 'SpotLight':
	                    uniforms = {
	                        shadowIntensity: 1,
	                        shadowBias: 0,
	                        shadowNormalBias: 0,
	                        shadowRadius: 1,
	                        shadowMapSize: new Vector2()
	                    };
	                    break;
	                case 'PointLight':
	                    uniforms = {
	                        shadowIntensity: 1,
	                        shadowBias: 0,
	                        shadowNormalBias: 0,
	                        shadowRadius: 1,
	                        shadowMapSize: new Vector2(),
	                        shadowCameraNear: 1,
	                        shadowCameraFar: 1000
	                    };
	                    break;
	            }
	            lights[light.id] = uniforms;
	            return uniforms;
	        }
	    };
	}
	let nextVersion = 0;
	function shadowCastingAndTexturingLightsFirst(lightA, lightB) {
	    return (lightB.castShadow ? 2 : 0) - (lightA.castShadow ? 2 : 0) + (lightB.map ? 1 : 0) - (lightA.map ? 1 : 0);
	}
	function WebGLLights(extensions) {
	    const cache = new UniformsCache();
	    const shadowCache = ShadowUniformsCache();
	    const state = {
	        version: 0,
	        hash: {
	            directionalLength: -1,
	            pointLength: -1,
	            spotLength: -1,
	            rectAreaLength: -1,
	            hemiLength: -1,
	            numDirectionalShadows: -1,
	            numPointShadows: -1,
	            numSpotShadows: -1,
	            numSpotMaps: -1,
	            numLightProbes: -1
	        },
	        ambient: [
	            0,
	            0,
	            0
	        ],
	        probe: [],
	        directional: [],
	        directionalShadow: [],
	        directionalShadowMap: [],
	        directionalShadowMatrix: [],
	        spot: [],
	        spotLightMap: [],
	        spotShadow: [],
	        spotShadowMap: [],
	        spotLightMatrix: [],
	        rectArea: [],
	        rectAreaLTC1: null,
	        rectAreaLTC2: null,
	        point: [],
	        pointShadow: [],
	        pointShadowMap: [],
	        pointShadowMatrix: [],
	        hemi: [],
	        numSpotLightShadowsWithMaps: 0,
	        numLightProbes: 0
	    };
	    for(let i = 0; i < 9; i++)state.probe.push(new Vector3());
	    const vector3 = new Vector3();
	    const matrix4 = new Matrix4();
	    const matrix42 = new Matrix4();
	    function setup(lights) {
	        let r = 0, g = 0, b = 0;
	        for(let i = 0; i < 9; i++)state.probe[i].set(0, 0, 0);
	        let directionalLength = 0;
	        let pointLength = 0;
	        let spotLength = 0;
	        let rectAreaLength = 0;
	        let hemiLength = 0;
	        let numDirectionalShadows = 0;
	        let numPointShadows = 0;
	        let numSpotShadows = 0;
	        let numSpotMaps = 0;
	        let numSpotShadowsWithMaps = 0;
	        let numLightProbes = 0;
	        // ordering : [shadow casting + map texturing, map texturing, shadow casting, none ]
	        lights.sort(shadowCastingAndTexturingLightsFirst);
	        for(let i = 0, l = lights.length; i < l; i++){
	            const light = lights[i];
	            const color = light.color;
	            const intensity = light.intensity;
	            const distance = light.distance;
	            const shadowMap = light.shadow && light.shadow.map ? light.shadow.map.texture : null;
	            if (light.isAmbientLight) {
	                r += color.r * intensity;
	                g += color.g * intensity;
	                b += color.b * intensity;
	            } else if (light.isLightProbe) {
	                for(let j = 0; j < 9; j++){
	                    state.probe[j].addScaledVector(light.sh.coefficients[j], intensity);
	                }
	                numLightProbes++;
	            } else if (light.isDirectionalLight) {
	                const uniforms = cache.get(light);
	                uniforms.color.copy(light.color).multiplyScalar(light.intensity);
	                if (light.castShadow) {
	                    const shadow = light.shadow;
	                    const shadowUniforms = shadowCache.get(light);
	                    shadowUniforms.shadowIntensity = shadow.intensity;
	                    shadowUniforms.shadowBias = shadow.bias;
	                    shadowUniforms.shadowNormalBias = shadow.normalBias;
	                    shadowUniforms.shadowRadius = shadow.radius;
	                    shadowUniforms.shadowMapSize = shadow.mapSize;
	                    state.directionalShadow[directionalLength] = shadowUniforms;
	                    state.directionalShadowMap[directionalLength] = shadowMap;
	                    state.directionalShadowMatrix[directionalLength] = light.shadow.matrix;
	                    numDirectionalShadows++;
	                }
	                state.directional[directionalLength] = uniforms;
	                directionalLength++;
	            } else if (light.isSpotLight) {
	                const uniforms = cache.get(light);
	                uniforms.position.setFromMatrixPosition(light.matrixWorld);
	                uniforms.color.copy(color).multiplyScalar(intensity);
	                uniforms.distance = distance;
	                uniforms.coneCos = Math.cos(light.angle);
	                uniforms.penumbraCos = Math.cos(light.angle * (1 - light.penumbra));
	                uniforms.decay = light.decay;
	                state.spot[spotLength] = uniforms;
	                const shadow = light.shadow;
	                if (light.map) {
	                    state.spotLightMap[numSpotMaps] = light.map;
	                    numSpotMaps++;
	                    // make sure the lightMatrix is up to date
	                    // TODO : do it if required only
	                    shadow.updateMatrices(light);
	                    if (light.castShadow) numSpotShadowsWithMaps++;
	                }
	                state.spotLightMatrix[spotLength] = shadow.matrix;
	                if (light.castShadow) {
	                    const shadowUniforms = shadowCache.get(light);
	                    shadowUniforms.shadowIntensity = shadow.intensity;
	                    shadowUniforms.shadowBias = shadow.bias;
	                    shadowUniforms.shadowNormalBias = shadow.normalBias;
	                    shadowUniforms.shadowRadius = shadow.radius;
	                    shadowUniforms.shadowMapSize = shadow.mapSize;
	                    state.spotShadow[spotLength] = shadowUniforms;
	                    state.spotShadowMap[spotLength] = shadowMap;
	                    numSpotShadows++;
	                }
	                spotLength++;
	            } else if (light.isRectAreaLight) {
	                const uniforms = cache.get(light);
	                uniforms.color.copy(color).multiplyScalar(intensity);
	                uniforms.halfWidth.set(light.width * 0.5, 0.0, 0.0);
	                uniforms.halfHeight.set(0.0, light.height * 0.5, 0.0);
	                state.rectArea[rectAreaLength] = uniforms;
	                rectAreaLength++;
	            } else if (light.isPointLight) {
	                const uniforms = cache.get(light);
	                uniforms.color.copy(light.color).multiplyScalar(light.intensity);
	                uniforms.distance = light.distance;
	                uniforms.decay = light.decay;
	                if (light.castShadow) {
	                    const shadow = light.shadow;
	                    const shadowUniforms = shadowCache.get(light);
	                    shadowUniforms.shadowIntensity = shadow.intensity;
	                    shadowUniforms.shadowBias = shadow.bias;
	                    shadowUniforms.shadowNormalBias = shadow.normalBias;
	                    shadowUniforms.shadowRadius = shadow.radius;
	                    shadowUniforms.shadowMapSize = shadow.mapSize;
	                    shadowUniforms.shadowCameraNear = shadow.camera.near;
	                    shadowUniforms.shadowCameraFar = shadow.camera.far;
	                    state.pointShadow[pointLength] = shadowUniforms;
	                    state.pointShadowMap[pointLength] = shadowMap;
	                    state.pointShadowMatrix[pointLength] = light.shadow.matrix;
	                    numPointShadows++;
	                }
	                state.point[pointLength] = uniforms;
	                pointLength++;
	            } else if (light.isHemisphereLight) {
	                const uniforms = cache.get(light);
	                uniforms.skyColor.copy(light.color).multiplyScalar(intensity);
	                uniforms.groundColor.copy(light.groundColor).multiplyScalar(intensity);
	                state.hemi[hemiLength] = uniforms;
	                hemiLength++;
	            }
	        }
	        if (rectAreaLength > 0) {
	            if (extensions.has('OES_texture_float_linear') === true) {
	                state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1;
	                state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2;
	            } else {
	                state.rectAreaLTC1 = UniformsLib.LTC_HALF_1;
	                state.rectAreaLTC2 = UniformsLib.LTC_HALF_2;
	            }
	        }
	        state.ambient[0] = r;
	        state.ambient[1] = g;
	        state.ambient[2] = b;
	        const hash = state.hash;
	        if (hash.directionalLength !== directionalLength || hash.pointLength !== pointLength || hash.spotLength !== spotLength || hash.rectAreaLength !== rectAreaLength || hash.hemiLength !== hemiLength || hash.numDirectionalShadows !== numDirectionalShadows || hash.numPointShadows !== numPointShadows || hash.numSpotShadows !== numSpotShadows || hash.numSpotMaps !== numSpotMaps || hash.numLightProbes !== numLightProbes) {
	            state.directional.length = directionalLength;
	            state.spot.length = spotLength;
	            state.rectArea.length = rectAreaLength;
	            state.point.length = pointLength;
	            state.hemi.length = hemiLength;
	            state.directionalShadow.length = numDirectionalShadows;
	            state.directionalShadowMap.length = numDirectionalShadows;
	            state.pointShadow.length = numPointShadows;
	            state.pointShadowMap.length = numPointShadows;
	            state.spotShadow.length = numSpotShadows;
	            state.spotShadowMap.length = numSpotShadows;
	            state.directionalShadowMatrix.length = numDirectionalShadows;
	            state.pointShadowMatrix.length = numPointShadows;
	            state.spotLightMatrix.length = numSpotShadows + numSpotMaps - numSpotShadowsWithMaps;
	            state.spotLightMap.length = numSpotMaps;
	            state.numSpotLightShadowsWithMaps = numSpotShadowsWithMaps;
	            state.numLightProbes = numLightProbes;
	            hash.directionalLength = directionalLength;
	            hash.pointLength = pointLength;
	            hash.spotLength = spotLength;
	            hash.rectAreaLength = rectAreaLength;
	            hash.hemiLength = hemiLength;
	            hash.numDirectionalShadows = numDirectionalShadows;
	            hash.numPointShadows = numPointShadows;
	            hash.numSpotShadows = numSpotShadows;
	            hash.numSpotMaps = numSpotMaps;
	            hash.numLightProbes = numLightProbes;
	            state.version = nextVersion++;
	        }
	    }
	    function setupView(lights, camera) {
	        let directionalLength = 0;
	        let pointLength = 0;
	        let spotLength = 0;
	        let rectAreaLength = 0;
	        let hemiLength = 0;
	        const viewMatrix = camera.matrixWorldInverse;
	        for(let i = 0, l = lights.length; i < l; i++){
	            const light = lights[i];
	            if (light.isDirectionalLight) {
	                const uniforms = state.directional[directionalLength];
	                uniforms.direction.setFromMatrixPosition(light.matrixWorld);
	                vector3.setFromMatrixPosition(light.target.matrixWorld);
	                uniforms.direction.sub(vector3);
	                uniforms.direction.transformDirection(viewMatrix);
	                directionalLength++;
	            } else if (light.isSpotLight) {
	                const uniforms = state.spot[spotLength];
	                uniforms.position.setFromMatrixPosition(light.matrixWorld);
	                uniforms.position.applyMatrix4(viewMatrix);
	                uniforms.direction.setFromMatrixPosition(light.matrixWorld);
	                vector3.setFromMatrixPosition(light.target.matrixWorld);
	                uniforms.direction.sub(vector3);
	                uniforms.direction.transformDirection(viewMatrix);
	                spotLength++;
	            } else if (light.isRectAreaLight) {
	                const uniforms = state.rectArea[rectAreaLength];
	                uniforms.position.setFromMatrixPosition(light.matrixWorld);
	                uniforms.position.applyMatrix4(viewMatrix);
	                // extract local rotation of light to derive width/height half vectors
	                matrix42.identity();
	                matrix4.copy(light.matrixWorld);
	                matrix4.premultiply(viewMatrix);
	                matrix42.extractRotation(matrix4);
	                uniforms.halfWidth.set(light.width * 0.5, 0.0, 0.0);
	                uniforms.halfHeight.set(0.0, light.height * 0.5, 0.0);
	                uniforms.halfWidth.applyMatrix4(matrix42);
	                uniforms.halfHeight.applyMatrix4(matrix42);
	                rectAreaLength++;
	            } else if (light.isPointLight) {
	                const uniforms = state.point[pointLength];
	                uniforms.position.setFromMatrixPosition(light.matrixWorld);
	                uniforms.position.applyMatrix4(viewMatrix);
	                pointLength++;
	            } else if (light.isHemisphereLight) {
	                const uniforms = state.hemi[hemiLength];
	                uniforms.direction.setFromMatrixPosition(light.matrixWorld);
	                uniforms.direction.transformDirection(viewMatrix);
	                hemiLength++;
	            }
	        }
	    }
	    return {
	        setup: setup,
	        setupView: setupView,
	        state: state
	    };
	}
	function WebGLRenderState(extensions) {
	    const lights = new WebGLLights(extensions);
	    const lightsArray = [];
	    const shadowsArray = [];
	    function init(camera) {
	        state.camera = camera;
	        lightsArray.length = 0;
	        shadowsArray.length = 0;
	    }
	    function pushLight(light) {
	        lightsArray.push(light);
	    }
	    function pushShadow(shadowLight) {
	        shadowsArray.push(shadowLight);
	    }
	    function setupLights() {
	        lights.setup(lightsArray);
	    }
	    function setupLightsView(camera) {
	        lights.setupView(lightsArray, camera);
	    }
	    const state = {
	        lightsArray: lightsArray,
	        shadowsArray: shadowsArray,
	        camera: null,
	        lights: lights,
	        transmissionRenderTarget: {}
	    };
	    return {
	        init: init,
	        state: state,
	        setupLights: setupLights,
	        setupLightsView: setupLightsView,
	        pushLight: pushLight,
	        pushShadow: pushShadow
	    };
	}
	function WebGLRenderStates(extensions) {
	    let renderStates = new WeakMap();
	    function get(scene, renderCallDepth = 0) {
	        const renderStateArray = renderStates.get(scene);
	        let renderState;
	        if (renderStateArray === undefined) {
	            renderState = new WebGLRenderState(extensions);
	            renderStates.set(scene, [
	                renderState
	            ]);
	        } else {
	            if (renderCallDepth >= renderStateArray.length) {
	                renderState = new WebGLRenderState(extensions);
	                renderStateArray.push(renderState);
	            } else {
	                renderState = renderStateArray[renderCallDepth];
	            }
	        }
	        return renderState;
	    }
	    function dispose() {
	        renderStates = new WeakMap();
	    }
	    return {
	        get: get,
	        dispose: dispose
	    };
	}
	const vertex = "void main() {\n\tgl_Position = vec4( position, 1.0 );\n}";
	const fragment = "uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";
	function WebGLShadowMap(renderer, objects, capabilities) {
	    let _frustum = new Frustum();
	    const _shadowMapSize = new Vector2(), _viewportSize = new Vector2(), _viewport = new Vector4(), _depthMaterial = new MeshDepthMaterial({
	        depthPacking: RGBADepthPacking
	    }), _distanceMaterial = new MeshDistanceMaterial(), _materialCache = {}, _maxTextureSize = capabilities.maxTextureSize;
	    const shadowSide = {
	        [FrontSide]: BackSide,
	        [BackSide]: FrontSide,
	        [DoubleSide]: DoubleSide
	    };
	    const shadowMaterialVertical = new ShaderMaterial({
	        defines: {
	            VSM_SAMPLES: 8
	        },
	        uniforms: {
	            shadow_pass: {
	                value: null
	            },
	            resolution: {
	                value: new Vector2()
	            },
	            radius: {
	                value: 4.0
	            }
	        },
	        vertexShader: vertex,
	        fragmentShader: fragment
	    });
	    const shadowMaterialHorizontal = shadowMaterialVertical.clone();
	    shadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1;
	    const fullScreenTri = new BufferGeometry();
	    fullScreenTri.setAttribute('position', new BufferAttribute(new Float32Array([
	        -1,
	        -1,
	        0.5,
	        3,
	        -1,
	        0.5,
	        -1,
	        3,
	        0.5
	    ]), 3));
	    const fullScreenMesh = new Mesh(fullScreenTri, shadowMaterialVertical);
	    const scope = this;
	    this.enabled = false;
	    this.autoUpdate = true;
	    this.needsUpdate = false;
	    this.type = PCFShadowMap;
	    let _previousType = this.type;
	    this.render = function(lights, scene, camera) {
	        if (scope.enabled === false) return;
	        if (scope.autoUpdate === false && scope.needsUpdate === false) return;
	        if (lights.length === 0) return;
	        const currentRenderTarget = renderer.getRenderTarget();
	        const activeCubeFace = renderer.getActiveCubeFace();
	        const activeMipmapLevel = renderer.getActiveMipmapLevel();
	        const _state = renderer.state;
	        // Set GL state for depth map.
	        _state.setBlending(NoBlending);
	        _state.buffers.color.setClear(1, 1, 1, 1);
	        _state.buffers.depth.setTest(true);
	        _state.setScissorTest(false);
	        // check for shadow map type changes
	        const toVSM = _previousType !== VSMShadowMap && this.type === VSMShadowMap;
	        const fromVSM = _previousType === VSMShadowMap && this.type !== VSMShadowMap;
	        // render depth map
	        for(let i = 0, il = lights.length; i < il; i++){
	            const light = lights[i];
	            const shadow = light.shadow;
	            if (shadow === undefined) {
	                console.warn('THREE.WebGLShadowMap:', light, 'has no shadow.');
	                continue;
	            }
	            if (shadow.autoUpdate === false && shadow.needsUpdate === false) continue;
	            _shadowMapSize.copy(shadow.mapSize);
	            const shadowFrameExtents = shadow.getFrameExtents();
	            _shadowMapSize.multiply(shadowFrameExtents);
	            _viewportSize.copy(shadow.mapSize);
	            if (_shadowMapSize.x > _maxTextureSize || _shadowMapSize.y > _maxTextureSize) {
	                if (_shadowMapSize.x > _maxTextureSize) {
	                    _viewportSize.x = Math.floor(_maxTextureSize / shadowFrameExtents.x);
	                    _shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x;
	                    shadow.mapSize.x = _viewportSize.x;
	                }
	                if (_shadowMapSize.y > _maxTextureSize) {
	                    _viewportSize.y = Math.floor(_maxTextureSize / shadowFrameExtents.y);
	                    _shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y;
	                    shadow.mapSize.y = _viewportSize.y;
	                }
	            }
	            if (shadow.map === null || toVSM === true || fromVSM === true) {
	                const pars = this.type !== VSMShadowMap ? {
	                    minFilter: NearestFilter,
	                    magFilter: NearestFilter
	                } : {};
	                if (shadow.map !== null) {
	                    shadow.map.dispose();
	                }
	                shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
	                shadow.map.texture.name = light.name + '.shadowMap';
	                shadow.camera.updateProjectionMatrix();
	            }
	            renderer.setRenderTarget(shadow.map);
	            renderer.clear();
	            const viewportCount = shadow.getViewportCount();
	            for(let vp = 0; vp < viewportCount; vp++){
	                const viewport = shadow.getViewport(vp);
	                _viewport.set(_viewportSize.x * viewport.x, _viewportSize.y * viewport.y, _viewportSize.x * viewport.z, _viewportSize.y * viewport.w);
	                _state.viewport(_viewport);
	                shadow.updateMatrices(light, vp);
	                _frustum = shadow.getFrustum();
	                renderObject(scene, camera, shadow.camera, light, this.type);
	            }
	            // do blur pass for VSM
	            if (shadow.isPointLightShadow !== true && this.type === VSMShadowMap) {
	                VSMPass(shadow, camera);
	            }
	            shadow.needsUpdate = false;
	        }
	        _previousType = this.type;
	        scope.needsUpdate = false;
	        renderer.setRenderTarget(currentRenderTarget, activeCubeFace, activeMipmapLevel);
	    };
	    function VSMPass(shadow, camera) {
	        const geometry = objects.update(fullScreenMesh);
	        if (shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples) {
	            shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples;
	            shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;
	            shadowMaterialVertical.needsUpdate = true;
	            shadowMaterialHorizontal.needsUpdate = true;
	        }
	        if (shadow.mapPass === null) {
	            shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y);
	        }
	        // vertical pass
	        shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture;
	        shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize;
	        shadowMaterialVertical.uniforms.radius.value = shadow.radius;
	        renderer.setRenderTarget(shadow.mapPass);
	        renderer.clear();
	        renderer.renderBufferDirect(camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null);
	        // horizontal pass
	        shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture;
	        shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize;
	        shadowMaterialHorizontal.uniforms.radius.value = shadow.radius;
	        renderer.setRenderTarget(shadow.map);
	        renderer.clear();
	        renderer.renderBufferDirect(camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null);
	    }
	    function getDepthMaterial(object, material, light, type) {
	        let result = null;
	        const customMaterial = light.isPointLight === true ? object.customDistanceMaterial : object.customDepthMaterial;
	        if (customMaterial !== undefined) {
	            result = customMaterial;
	        } else {
	            result = light.isPointLight === true ? _distanceMaterial : _depthMaterial;
	            if (renderer.localClippingEnabled && material.clipShadows === true && Array.isArray(material.clippingPlanes) && material.clippingPlanes.length !== 0 || material.displacementMap && material.displacementScale !== 0 || material.alphaMap && material.alphaTest > 0 || material.map && material.alphaTest > 0) {
	                // in this case we need a unique material instance reflecting the
	                // appropriate state
	                const keyA = result.uuid, keyB = material.uuid;
	                let materialsForVariant = _materialCache[keyA];
	                if (materialsForVariant === undefined) {
	                    materialsForVariant = {};
	                    _materialCache[keyA] = materialsForVariant;
	                }
	                let cachedMaterial = materialsForVariant[keyB];
	                if (cachedMaterial === undefined) {
	                    cachedMaterial = result.clone();
	                    materialsForVariant[keyB] = cachedMaterial;
	                    material.addEventListener('dispose', onMaterialDispose);
	                }
	                result = cachedMaterial;
	            }
	        }
	        result.visible = material.visible;
	        result.wireframe = material.wireframe;
	        if (type === VSMShadowMap) {
	            result.side = material.shadowSide !== null ? material.shadowSide : material.side;
	        } else {
	            result.side = material.shadowSide !== null ? material.shadowSide : shadowSide[material.side];
	        }
	        result.alphaMap = material.alphaMap;
	        result.alphaTest = material.alphaTest;
	        result.map = material.map;
	        result.clipShadows = material.clipShadows;
	        result.clippingPlanes = material.clippingPlanes;
	        result.clipIntersection = material.clipIntersection;
	        result.displacementMap = material.displacementMap;
	        result.displacementScale = material.displacementScale;
	        result.displacementBias = material.displacementBias;
	        result.wireframeLinewidth = material.wireframeLinewidth;
	        result.linewidth = material.linewidth;
	        if (light.isPointLight === true && result.isMeshDistanceMaterial === true) {
	            const materialProperties = renderer.properties.get(result);
	            materialProperties.light = light;
	        }
	        return result;
	    }
	    function renderObject(object, camera, shadowCamera, light, type) {
	        if (object.visible === false) return;
	        const visible = object.layers.test(camera.layers);
	        if (visible && (object.isMesh || object.isLine || object.isPoints)) {
	            if ((object.castShadow || object.receiveShadow && type === VSMShadowMap) && (!object.frustumCulled || _frustum.intersectsObject(object))) {
	                object.modelViewMatrix.multiplyMatrices(shadowCamera.matrixWorldInverse, object.matrixWorld);
	                const geometry = objects.update(object);
	                const material = object.material;
	                if (Array.isArray(material)) {
	                    const groups = geometry.groups;
	                    for(let k = 0, kl = groups.length; k < kl; k++){
	                        const group = groups[k];
	                        const groupMaterial = material[group.materialIndex];
	                        if (groupMaterial && groupMaterial.visible) {
	                            const depthMaterial = getDepthMaterial(object, groupMaterial, light, type);
	                            object.onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, group);
	                            renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group);
	                            object.onAfterShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, group);
	                        }
	                    }
	                } else if (material.visible) {
	                    const depthMaterial = getDepthMaterial(object, material, light, type);
	                    object.onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, null);
	                    renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null);
	                    object.onAfterShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, null);
	                }
	            }
	        }
	        const children = object.children;
	        for(let i = 0, l = children.length; i < l; i++){
	            renderObject(children[i], camera, shadowCamera, light, type);
	        }
	    }
	    function onMaterialDispose(event) {
	        const material = event.target;
	        material.removeEventListener('dispose', onMaterialDispose);
	        // make sure to remove the unique distance/depth materials used for shadow map rendering
	        for(const id in _materialCache){
	            const cache = _materialCache[id];
	            const uuid = event.target.uuid;
	            if (uuid in cache) {
	                const shadowMaterial = cache[uuid];
	                shadowMaterial.dispose();
	                delete cache[uuid];
	            }
	        }
	    }
	}
	const reversedFuncs = {
	    [NeverDepth]: AlwaysDepth,
	    [LessDepth]: GreaterDepth,
	    [EqualDepth]: NotEqualDepth,
	    [LessEqualDepth]: GreaterEqualDepth,
	    [AlwaysDepth]: NeverDepth,
	    [GreaterDepth]: LessDepth,
	    [NotEqualDepth]: EqualDepth,
	    [GreaterEqualDepth]: LessEqualDepth
	};
	function WebGLState(gl, extensions) {
	    function ColorBuffer() {
	        let locked = false;
	        const color = new Vector4();
	        let currentColorMask = null;
	        const currentColorClear = new Vector4(0, 0, 0, 0);
	        return {
	            setMask: function(colorMask) {
	                if (currentColorMask !== colorMask && !locked) {
	                    gl.colorMask(colorMask, colorMask, colorMask, colorMask);
	                    currentColorMask = colorMask;
	                }
	            },
	            setLocked: function(lock) {
	                locked = lock;
	            },
	            setClear: function(r, g, b, a, premultipliedAlpha) {
	                if (premultipliedAlpha === true) {
	                    r *= a;
	                    g *= a;
	                    b *= a;
	                }
	                color.set(r, g, b, a);
	                if (currentColorClear.equals(color) === false) {
	                    gl.clearColor(r, g, b, a);
	                    currentColorClear.copy(color);
	                }
	            },
	            reset: function() {
	                locked = false;
	                currentColorMask = null;
	                currentColorClear.set(-1, 0, 0, 0); // set to invalid state
	            }
	        };
	    }
	    function DepthBuffer() {
	        let locked = false;
	        let reversed = false;
	        let currentDepthMask = null;
	        let currentDepthFunc = null;
	        let currentDepthClear = null;
	        return {
	            setReversed: function(value) {
	                if (reversed !== value) {
	                    const ext = extensions.get('EXT_clip_control');
	                    if (reversed) {
	                        ext.clipControlEXT(ext.LOWER_LEFT_EXT, ext.ZERO_TO_ONE_EXT);
	                    } else {
	                        ext.clipControlEXT(ext.LOWER_LEFT_EXT, ext.NEGATIVE_ONE_TO_ONE_EXT);
	                    }
	                    const oldDepth = currentDepthClear;
	                    currentDepthClear = null;
	                    this.setClear(oldDepth);
	                }
	                reversed = value;
	            },
	            getReversed: function() {
	                return reversed;
	            },
	            setTest: function(depthTest) {
	                if (depthTest) {
	                    enable(gl.DEPTH_TEST);
	                } else {
	                    disable(gl.DEPTH_TEST);
	                }
	            },
	            setMask: function(depthMask) {
	                if (currentDepthMask !== depthMask && !locked) {
	                    gl.depthMask(depthMask);
	                    currentDepthMask = depthMask;
	                }
	            },
	            setFunc: function(depthFunc) {
	                if (reversed) depthFunc = reversedFuncs[depthFunc];
	                if (currentDepthFunc !== depthFunc) {
	                    switch(depthFunc){
	                        case NeverDepth:
	                            gl.depthFunc(gl.NEVER);
	                            break;
	                        case AlwaysDepth:
	                            gl.depthFunc(gl.ALWAYS);
	                            break;
	                        case LessDepth:
	                            gl.depthFunc(gl.LESS);
	                            break;
	                        case LessEqualDepth:
	                            gl.depthFunc(gl.LEQUAL);
	                            break;
	                        case EqualDepth:
	                            gl.depthFunc(gl.EQUAL);
	                            break;
	                        case GreaterEqualDepth:
	                            gl.depthFunc(gl.GEQUAL);
	                            break;
	                        case GreaterDepth:
	                            gl.depthFunc(gl.GREATER);
	                            break;
	                        case NotEqualDepth:
	                            gl.depthFunc(gl.NOTEQUAL);
	                            break;
	                        default:
	                            gl.depthFunc(gl.LEQUAL);
	                    }
	                    currentDepthFunc = depthFunc;
	                }
	            },
	            setLocked: function(lock) {
	                locked = lock;
	            },
	            setClear: function(depth) {
	                if (currentDepthClear !== depth) {
	                    if (reversed) {
	                        depth = 1 - depth;
	                    }
	                    gl.clearDepth(depth);
	                    currentDepthClear = depth;
	                }
	            },
	            reset: function() {
	                locked = false;
	                currentDepthMask = null;
	                currentDepthFunc = null;
	                currentDepthClear = null;
	                reversed = false;
	            }
	        };
	    }
	    function StencilBuffer() {
	        let locked = false;
	        let currentStencilMask = null;
	        let currentStencilFunc = null;
	        let currentStencilRef = null;
	        let currentStencilFuncMask = null;
	        let currentStencilFail = null;
	        let currentStencilZFail = null;
	        let currentStencilZPass = null;
	        let currentStencilClear = null;
	        return {
	            setTest: function(stencilTest) {
	                if (!locked) {
	                    if (stencilTest) {
	                        enable(gl.STENCIL_TEST);
	                    } else {
	                        disable(gl.STENCIL_TEST);
	                    }
	                }
	            },
	            setMask: function(stencilMask) {
	                if (currentStencilMask !== stencilMask && !locked) {
	                    gl.stencilMask(stencilMask);
	                    currentStencilMask = stencilMask;
	                }
	            },
	            setFunc: function(stencilFunc, stencilRef, stencilMask) {
	                if (currentStencilFunc !== stencilFunc || currentStencilRef !== stencilRef || currentStencilFuncMask !== stencilMask) {
	                    gl.stencilFunc(stencilFunc, stencilRef, stencilMask);
	                    currentStencilFunc = stencilFunc;
	                    currentStencilRef = stencilRef;
	                    currentStencilFuncMask = stencilMask;
	                }
	            },
	            setOp: function(stencilFail, stencilZFail, stencilZPass) {
	                if (currentStencilFail !== stencilFail || currentStencilZFail !== stencilZFail || currentStencilZPass !== stencilZPass) {
	                    gl.stencilOp(stencilFail, stencilZFail, stencilZPass);
	                    currentStencilFail = stencilFail;
	                    currentStencilZFail = stencilZFail;
	                    currentStencilZPass = stencilZPass;
	                }
	            },
	            setLocked: function(lock) {
	                locked = lock;
	            },
	            setClear: function(stencil) {
	                if (currentStencilClear !== stencil) {
	                    gl.clearStencil(stencil);
	                    currentStencilClear = stencil;
	                }
	            },
	            reset: function() {
	                locked = false;
	                currentStencilMask = null;
	                currentStencilFunc = null;
	                currentStencilRef = null;
	                currentStencilFuncMask = null;
	                currentStencilFail = null;
	                currentStencilZFail = null;
	                currentStencilZPass = null;
	                currentStencilClear = null;
	            }
	        };
	    }
	    //
	    const colorBuffer = new ColorBuffer();
	    const depthBuffer = new DepthBuffer();
	    const stencilBuffer = new StencilBuffer();
	    const uboBindings = new WeakMap();
	    const uboProgramMap = new WeakMap();
	    let enabledCapabilities = {};
	    let currentBoundFramebuffers = {};
	    let currentDrawbuffers = new WeakMap();
	    let defaultDrawbuffers = [];
	    let currentProgram = null;
	    let currentBlendingEnabled = false;
	    let currentBlending = null;
	    let currentBlendEquation = null;
	    let currentBlendSrc = null;
	    let currentBlendDst = null;
	    let currentBlendEquationAlpha = null;
	    let currentBlendSrcAlpha = null;
	    let currentBlendDstAlpha = null;
	    let currentBlendColor = new Color(0, 0, 0);
	    let currentBlendAlpha = 0;
	    let currentPremultipledAlpha = false;
	    let currentFlipSided = null;
	    let currentCullFace = null;
	    let currentLineWidth = null;
	    let currentPolygonOffsetFactor = null;
	    let currentPolygonOffsetUnits = null;
	    const maxTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
	    let lineWidthAvailable = false;
	    let version = 0;
	    const glVersion = gl.getParameter(gl.VERSION);
	    if (glVersion.indexOf('WebGL') !== -1) {
	        version = parseFloat(/^WebGL (\d)/.exec(glVersion)[1]);
	        lineWidthAvailable = version >= 1.0;
	    } else if (glVersion.indexOf('OpenGL ES') !== -1) {
	        version = parseFloat(/^OpenGL ES (\d)/.exec(glVersion)[1]);
	        lineWidthAvailable = version >= 2.0;
	    }
	    let currentTextureSlot = null;
	    let currentBoundTextures = {};
	    const scissorParam = gl.getParameter(gl.SCISSOR_BOX);
	    const viewportParam = gl.getParameter(gl.VIEWPORT);
	    const currentScissor = new Vector4().fromArray(scissorParam);
	    const currentViewport = new Vector4().fromArray(viewportParam);
	    function createTexture(type, target, count, dimensions) {
	        const data = new Uint8Array(4); // 4 is required to match default unpack alignment of 4.
	        const texture = gl.createTexture();
	        gl.bindTexture(type, texture);
	        gl.texParameteri(type, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
	        gl.texParameteri(type, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
	        for(let i = 0; i < count; i++){
	            if (type === gl.TEXTURE_3D || type === gl.TEXTURE_2D_ARRAY) {
	                gl.texImage3D(target, 0, gl.RGBA, 1, 1, dimensions, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
	            } else {
	                gl.texImage2D(target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
	            }
	        }
	        return texture;
	    }
	    const emptyTextures = {};
	    emptyTextures[gl.TEXTURE_2D] = createTexture(gl.TEXTURE_2D, gl.TEXTURE_2D, 1);
	    emptyTextures[gl.TEXTURE_CUBE_MAP] = createTexture(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6);
	    emptyTextures[gl.TEXTURE_2D_ARRAY] = createTexture(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_2D_ARRAY, 1, 1);
	    emptyTextures[gl.TEXTURE_3D] = createTexture(gl.TEXTURE_3D, gl.TEXTURE_3D, 1, 1);
	    // init
	    colorBuffer.setClear(0, 0, 0, 1);
	    depthBuffer.setClear(1);
	    stencilBuffer.setClear(0);
	    enable(gl.DEPTH_TEST);
	    depthBuffer.setFunc(LessEqualDepth);
	    setFlipSided(false);
	    setCullFace(CullFaceBack);
	    enable(gl.CULL_FACE);
	    setBlending(NoBlending);
	    //
	    function enable(id) {
	        if (enabledCapabilities[id] !== true) {
	            gl.enable(id);
	            enabledCapabilities[id] = true;
	        }
	    }
	    function disable(id) {
	        if (enabledCapabilities[id] !== false) {
	            gl.disable(id);
	            enabledCapabilities[id] = false;
	        }
	    }
	    function bindFramebuffer(target, framebuffer) {
	        if (currentBoundFramebuffers[target] !== framebuffer) {
	            gl.bindFramebuffer(target, framebuffer);
	            currentBoundFramebuffers[target] = framebuffer;
	            // gl.DRAW_FRAMEBUFFER is equivalent to gl.FRAMEBUFFER
	            if (target === gl.DRAW_FRAMEBUFFER) {
	                currentBoundFramebuffers[gl.FRAMEBUFFER] = framebuffer;
	            }
	            if (target === gl.FRAMEBUFFER) {
	                currentBoundFramebuffers[gl.DRAW_FRAMEBUFFER] = framebuffer;
	            }
	            return true;
	        }
	        return false;
	    }
	    function drawBuffers(renderTarget, framebuffer) {
	        let drawBuffers = defaultDrawbuffers;
	        let needsUpdate = false;
	        if (renderTarget) {
	            drawBuffers = currentDrawbuffers.get(framebuffer);
	            if (drawBuffers === undefined) {
	                drawBuffers = [];
	                currentDrawbuffers.set(framebuffer, drawBuffers);
	            }
	            const textures = renderTarget.textures;
	            if (drawBuffers.length !== textures.length || drawBuffers[0] !== gl.COLOR_ATTACHMENT0) {
	                for(let i = 0, il = textures.length; i < il; i++){
	                    drawBuffers[i] = gl.COLOR_ATTACHMENT0 + i;
	                }
	                drawBuffers.length = textures.length;
	                needsUpdate = true;
	            }
	        } else {
	            if (drawBuffers[0] !== gl.BACK) {
	                drawBuffers[0] = gl.BACK;
	                needsUpdate = true;
	            }
	        }
	        if (needsUpdate) {
	            gl.drawBuffers(drawBuffers);
	        }
	    }
	    function useProgram(program) {
	        if (currentProgram !== program) {
	            gl.useProgram(program);
	            currentProgram = program;
	            return true;
	        }
	        return false;
	    }
	    const equationToGL = {
	        [AddEquation]: gl.FUNC_ADD,
	        [SubtractEquation]: gl.FUNC_SUBTRACT,
	        [ReverseSubtractEquation]: gl.FUNC_REVERSE_SUBTRACT
	    };
	    equationToGL[MinEquation] = gl.MIN;
	    equationToGL[MaxEquation] = gl.MAX;
	    const factorToGL = {
	        [ZeroFactor]: gl.ZERO,
	        [OneFactor]: gl.ONE,
	        [SrcColorFactor]: gl.SRC_COLOR,
	        [SrcAlphaFactor]: gl.SRC_ALPHA,
	        [SrcAlphaSaturateFactor]: gl.SRC_ALPHA_SATURATE,
	        [DstColorFactor]: gl.DST_COLOR,
	        [DstAlphaFactor]: gl.DST_ALPHA,
	        [OneMinusSrcColorFactor]: gl.ONE_MINUS_SRC_COLOR,
	        [OneMinusSrcAlphaFactor]: gl.ONE_MINUS_SRC_ALPHA,
	        [OneMinusDstColorFactor]: gl.ONE_MINUS_DST_COLOR,
	        [OneMinusDstAlphaFactor]: gl.ONE_MINUS_DST_ALPHA,
	        [ConstantColorFactor]: gl.CONSTANT_COLOR,
	        [OneMinusConstantColorFactor]: gl.ONE_MINUS_CONSTANT_COLOR,
	        [ConstantAlphaFactor]: gl.CONSTANT_ALPHA,
	        [OneMinusConstantAlphaFactor]: gl.ONE_MINUS_CONSTANT_ALPHA
	    };
	    function setBlending(blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, blendColor, blendAlpha, premultipliedAlpha) {
	        if (blending === NoBlending) {
	            if (currentBlendingEnabled === true) {
	                disable(gl.BLEND);
	                currentBlendingEnabled = false;
	            }
	            return;
	        }
	        if (currentBlendingEnabled === false) {
	            enable(gl.BLEND);
	            currentBlendingEnabled = true;
	        }
	        if (blending !== CustomBlending) {
	            if (blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha) {
	                if (currentBlendEquation !== AddEquation || currentBlendEquationAlpha !== AddEquation) {
	                    gl.blendEquation(gl.FUNC_ADD);
	                    currentBlendEquation = AddEquation;
	                    currentBlendEquationAlpha = AddEquation;
	                }
	                if (premultipliedAlpha) {
	                    switch(blending){
	                        case NormalBlending:
	                            gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
	                            break;
	                        case AdditiveBlending:
	                            gl.blendFunc(gl.ONE, gl.ONE);
	                            break;
	                        case SubtractiveBlending:
	                            gl.blendFuncSeparate(gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE);
	                            break;
	                        case MultiplyBlending:
	                            gl.blendFuncSeparate(gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA);
	                            break;
	                        default:
	                            console.error('THREE.WebGLState: Invalid blending: ', blending);
	                            break;
	                    }
	                } else {
	                    switch(blending){
	                        case NormalBlending:
	                            gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
	                            break;
	                        case AdditiveBlending:
	                            gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
	                            break;
	                        case SubtractiveBlending:
	                            gl.blendFuncSeparate(gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE);
	                            break;
	                        case MultiplyBlending:
	                            gl.blendFunc(gl.ZERO, gl.SRC_COLOR);
	                            break;
	                        default:
	                            console.error('THREE.WebGLState: Invalid blending: ', blending);
	                            break;
	                    }
	                }
	                currentBlendSrc = null;
	                currentBlendDst = null;
	                currentBlendSrcAlpha = null;
	                currentBlendDstAlpha = null;
	                currentBlendColor.set(0, 0, 0);
	                currentBlendAlpha = 0;
	                currentBlending = blending;
	                currentPremultipledAlpha = premultipliedAlpha;
	            }
	            return;
	        }
	        // custom blending
	        blendEquationAlpha = blendEquationAlpha || blendEquation;
	        blendSrcAlpha = blendSrcAlpha || blendSrc;
	        blendDstAlpha = blendDstAlpha || blendDst;
	        if (blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha) {
	            gl.blendEquationSeparate(equationToGL[blendEquation], equationToGL[blendEquationAlpha]);
	            currentBlendEquation = blendEquation;
	            currentBlendEquationAlpha = blendEquationAlpha;
	        }
	        if (blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha) {
	            gl.blendFuncSeparate(factorToGL[blendSrc], factorToGL[blendDst], factorToGL[blendSrcAlpha], factorToGL[blendDstAlpha]);
	            currentBlendSrc = blendSrc;
	            currentBlendDst = blendDst;
	            currentBlendSrcAlpha = blendSrcAlpha;
	            currentBlendDstAlpha = blendDstAlpha;
	        }
	        if (blendColor.equals(currentBlendColor) === false || blendAlpha !== currentBlendAlpha) {
	            gl.blendColor(blendColor.r, blendColor.g, blendColor.b, blendAlpha);
	            currentBlendColor.copy(blendColor);
	            currentBlendAlpha = blendAlpha;
	        }
	        currentBlending = blending;
	        currentPremultipledAlpha = false;
	    }
	    function setMaterial(material, frontFaceCW) {
	        material.side === DoubleSide ? disable(gl.CULL_FACE) : enable(gl.CULL_FACE);
	        let flipSided = material.side === BackSide;
	        if (frontFaceCW) flipSided = !flipSided;
	        setFlipSided(flipSided);
	        material.blending === NormalBlending && material.transparent === false ? setBlending(NoBlending) : setBlending(material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha);
	        depthBuffer.setFunc(material.depthFunc);
	        depthBuffer.setTest(material.depthTest);
	        depthBuffer.setMask(material.depthWrite);
	        colorBuffer.setMask(material.colorWrite);
	        const stencilWrite = material.stencilWrite;
	        stencilBuffer.setTest(stencilWrite);
	        if (stencilWrite) {
	            stencilBuffer.setMask(material.stencilWriteMask);
	            stencilBuffer.setFunc(material.stencilFunc, material.stencilRef, material.stencilFuncMask);
	            stencilBuffer.setOp(material.stencilFail, material.stencilZFail, material.stencilZPass);
	        }
	        setPolygonOffset(material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits);
	        material.alphaToCoverage === true ? enable(gl.SAMPLE_ALPHA_TO_COVERAGE) : disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
	    }
	    //
	    function setFlipSided(flipSided) {
	        if (currentFlipSided !== flipSided) {
	            if (flipSided) {
	                gl.frontFace(gl.CW);
	            } else {
	                gl.frontFace(gl.CCW);
	            }
	            currentFlipSided = flipSided;
	        }
	    }
	    function setCullFace(cullFace) {
	        if (cullFace !== CullFaceNone) {
	            enable(gl.CULL_FACE);
	            if (cullFace !== currentCullFace) {
	                if (cullFace === CullFaceBack) {
	                    gl.cullFace(gl.BACK);
	                } else if (cullFace === CullFaceFront) {
	                    gl.cullFace(gl.FRONT);
	                } else {
	                    gl.cullFace(gl.FRONT_AND_BACK);
	                }
	            }
	        } else {
	            disable(gl.CULL_FACE);
	        }
	        currentCullFace = cullFace;
	    }
	    function setLineWidth(width) {
	        if (width !== currentLineWidth) {
	            if (lineWidthAvailable) gl.lineWidth(width);
	            currentLineWidth = width;
	        }
	    }
	    function setPolygonOffset(polygonOffset, factor, units) {
	        if (polygonOffset) {
	            enable(gl.POLYGON_OFFSET_FILL);
	            if (currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units) {
	                gl.polygonOffset(factor, units);
	                currentPolygonOffsetFactor = factor;
	                currentPolygonOffsetUnits = units;
	            }
	        } else {
	            disable(gl.POLYGON_OFFSET_FILL);
	        }
	    }
	    function setScissorTest(scissorTest) {
	        if (scissorTest) {
	            enable(gl.SCISSOR_TEST);
	        } else {
	            disable(gl.SCISSOR_TEST);
	        }
	    }
	    // texture
	    function activeTexture(webglSlot) {
	        if (webglSlot === undefined) webglSlot = gl.TEXTURE0 + maxTextures - 1;
	        if (currentTextureSlot !== webglSlot) {
	            gl.activeTexture(webglSlot);
	            currentTextureSlot = webglSlot;
	        }
	    }
	    function bindTexture(webglType, webglTexture, webglSlot) {
	        if (webglSlot === undefined) {
	            if (currentTextureSlot === null) {
	                webglSlot = gl.TEXTURE0 + maxTextures - 1;
	            } else {
	                webglSlot = currentTextureSlot;
	            }
	        }
	        let boundTexture = currentBoundTextures[webglSlot];
	        if (boundTexture === undefined) {
	            boundTexture = {
	                type: undefined,
	                texture: undefined
	            };
	            currentBoundTextures[webglSlot] = boundTexture;
	        }
	        if (boundTexture.type !== webglType || boundTexture.texture !== webglTexture) {
	            if (currentTextureSlot !== webglSlot) {
	                gl.activeTexture(webglSlot);
	                currentTextureSlot = webglSlot;
	            }
	            gl.bindTexture(webglType, webglTexture || emptyTextures[webglType]);
	            boundTexture.type = webglType;
	            boundTexture.texture = webglTexture;
	        }
	    }
	    function unbindTexture() {
	        const boundTexture = currentBoundTextures[currentTextureSlot];
	        if (boundTexture !== undefined && boundTexture.type !== undefined) {
	            gl.bindTexture(boundTexture.type, null);
	            boundTexture.type = undefined;
	            boundTexture.texture = undefined;
	        }
	    }
	    function compressedTexImage2D() {
	        try {
	            gl.compressedTexImage2D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function compressedTexImage3D() {
	        try {
	            gl.compressedTexImage3D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function texSubImage2D() {
	        try {
	            gl.texSubImage2D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function texSubImage3D() {
	        try {
	            gl.texSubImage3D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function compressedTexSubImage2D() {
	        try {
	            gl.compressedTexSubImage2D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function compressedTexSubImage3D() {
	        try {
	            gl.compressedTexSubImage3D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function texStorage2D() {
	        try {
	            gl.texStorage2D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function texStorage3D() {
	        try {
	            gl.texStorage3D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function texImage2D() {
	        try {
	            gl.texImage2D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    function texImage3D() {
	        try {
	            gl.texImage3D(...arguments);
	        } catch (error) {
	            console.error('THREE.WebGLState:', error);
	        }
	    }
	    //
	    function scissor(scissor) {
	        if (currentScissor.equals(scissor) === false) {
	            gl.scissor(scissor.x, scissor.y, scissor.z, scissor.w);
	            currentScissor.copy(scissor);
	        }
	    }
	    function viewport(viewport) {
	        if (currentViewport.equals(viewport) === false) {
	            gl.viewport(viewport.x, viewport.y, viewport.z, viewport.w);
	            currentViewport.copy(viewport);
	        }
	    }
	    function updateUBOMapping(uniformsGroup, program) {
	        let mapping = uboProgramMap.get(program);
	        if (mapping === undefined) {
	            mapping = new WeakMap();
	            uboProgramMap.set(program, mapping);
	        }
	        let blockIndex = mapping.get(uniformsGroup);
	        if (blockIndex === undefined) {
	            blockIndex = gl.getUniformBlockIndex(program, uniformsGroup.name);
	            mapping.set(uniformsGroup, blockIndex);
	        }
	    }
	    function uniformBlockBinding(uniformsGroup, program) {
	        const mapping = uboProgramMap.get(program);
	        const blockIndex = mapping.get(uniformsGroup);
	        if (uboBindings.get(program) !== blockIndex) {
	            // bind shader specific block index to global block point
	            gl.uniformBlockBinding(program, blockIndex, uniformsGroup.__bindingPointIndex);
	            uboBindings.set(program, blockIndex);
	        }
	    }
	    //
	    function reset() {
	        // reset state
	        gl.disable(gl.BLEND);
	        gl.disable(gl.CULL_FACE);
	        gl.disable(gl.DEPTH_TEST);
	        gl.disable(gl.POLYGON_OFFSET_FILL);
	        gl.disable(gl.SCISSOR_TEST);
	        gl.disable(gl.STENCIL_TEST);
	        gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
	        gl.blendEquation(gl.FUNC_ADD);
	        gl.blendFunc(gl.ONE, gl.ZERO);
	        gl.blendFuncSeparate(gl.ONE, gl.ZERO, gl.ONE, gl.ZERO);
	        gl.blendColor(0, 0, 0, 0);
	        gl.colorMask(true, true, true, true);
	        gl.clearColor(0, 0, 0, 0);
	        gl.depthMask(true);
	        gl.depthFunc(gl.LESS);
	        depthBuffer.setReversed(false);
	        gl.clearDepth(1);
	        gl.stencilMask(0xffffffff);
	        gl.stencilFunc(gl.ALWAYS, 0, 0xffffffff);
	        gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
	        gl.clearStencil(0);
	        gl.cullFace(gl.BACK);
	        gl.frontFace(gl.CCW);
	        gl.polygonOffset(0, 0);
	        gl.activeTexture(gl.TEXTURE0);
	        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
	        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
	        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
	        gl.useProgram(null);
	        gl.lineWidth(1);
	        gl.scissor(0, 0, gl.canvas.width, gl.canvas.height);
	        gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
	        // reset internals
	        enabledCapabilities = {};
	        currentTextureSlot = null;
	        currentBoundTextures = {};
	        currentBoundFramebuffers = {};
	        currentDrawbuffers = new WeakMap();
	        defaultDrawbuffers = [];
	        currentProgram = null;
	        currentBlendingEnabled = false;
	        currentBlending = null;
	        currentBlendEquation = null;
	        currentBlendSrc = null;
	        currentBlendDst = null;
	        currentBlendEquationAlpha = null;
	        currentBlendSrcAlpha = null;
	        currentBlendDstAlpha = null;
	        currentBlendColor = new Color(0, 0, 0);
	        currentBlendAlpha = 0;
	        currentPremultipledAlpha = false;
	        currentFlipSided = null;
	        currentCullFace = null;
	        currentLineWidth = null;
	        currentPolygonOffsetFactor = null;
	        currentPolygonOffsetUnits = null;
	        currentScissor.set(0, 0, gl.canvas.width, gl.canvas.height);
	        currentViewport.set(0, 0, gl.canvas.width, gl.canvas.height);
	        colorBuffer.reset();
	        depthBuffer.reset();
	        stencilBuffer.reset();
	    }
	    return {
	        buffers: {
	            color: colorBuffer,
	            depth: depthBuffer,
	            stencil: stencilBuffer
	        },
	        enable: enable,
	        disable: disable,
	        bindFramebuffer: bindFramebuffer,
	        drawBuffers: drawBuffers,
	        useProgram: useProgram,
	        setBlending: setBlending,
	        setMaterial: setMaterial,
	        setFlipSided: setFlipSided,
	        setCullFace: setCullFace,
	        setLineWidth: setLineWidth,
	        setPolygonOffset: setPolygonOffset,
	        setScissorTest: setScissorTest,
	        activeTexture: activeTexture,
	        bindTexture: bindTexture,
	        unbindTexture: unbindTexture,
	        compressedTexImage2D: compressedTexImage2D,
	        compressedTexImage3D: compressedTexImage3D,
	        texImage2D: texImage2D,
	        texImage3D: texImage3D,
	        updateUBOMapping: updateUBOMapping,
	        uniformBlockBinding: uniformBlockBinding,
	        texStorage2D: texStorage2D,
	        texStorage3D: texStorage3D,
	        texSubImage2D: texSubImage2D,
	        texSubImage3D: texSubImage3D,
	        compressedTexSubImage2D: compressedTexSubImage2D,
	        compressedTexSubImage3D: compressedTexSubImage3D,
	        scissor: scissor,
	        viewport: viewport,
	        reset: reset
	    };
	}
	function WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info) {
	    const multisampledRTTExt = extensions.has('WEBGL_multisampled_render_to_texture') ? extensions.get('WEBGL_multisampled_render_to_texture') : null;
	    const supportsInvalidateFramebuffer = typeof navigator === 'undefined' ? false : /OculusBrowser/g.test(navigator.userAgent);
	    const _imageDimensions = new Vector2();
	    const _videoTextures = new WeakMap();
	    let _canvas;
	    const _sources = new WeakMap(); // maps WebglTexture objects to instances of Source
	    // cordova iOS (as of 5.0) still uses UIWebView, which provides OffscreenCanvas,
	    // also OffscreenCanvas.getContext("webgl"), but not OffscreenCanvas.getContext("2d")!
	    // Some implementations may only implement OffscreenCanvas partially (e.g. lacking 2d).
	    let useOffscreenCanvas = false;
	    try {
	        useOffscreenCanvas = typeof OffscreenCanvas !== 'undefined' && new OffscreenCanvas(1, 1).getContext('2d') !== null;
	    } catch (err) {
	    // Ignore any errors
	    }
	    function createCanvas(width, height) {
	        // Use OffscreenCanvas when available. Specially needed in web workers
	        return useOffscreenCanvas ? // eslint-disable-next-line compat/compat
	        new OffscreenCanvas(width, height) : createElementNS('canvas');
	    }
	    function resizeImage(image, needsNewCanvas, maxSize) {
	        let scale = 1;
	        const dimensions = getDimensions(image);
	        // handle case if texture exceeds max size
	        if (dimensions.width > maxSize || dimensions.height > maxSize) {
	            scale = maxSize / Math.max(dimensions.width, dimensions.height);
	        }
	        // only perform resize if necessary
	        if (scale < 1) {
	            // only perform resize for certain image types
	            if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap || typeof VideoFrame !== 'undefined' && image instanceof VideoFrame) {
	                const width = Math.floor(scale * dimensions.width);
	                const height = Math.floor(scale * dimensions.height);
	                if (_canvas === undefined) _canvas = createCanvas(width, height);
	                // cube textures can't reuse the same canvas
	                const canvas = needsNewCanvas ? createCanvas(width, height) : _canvas;
	                canvas.width = width;
	                canvas.height = height;
	                const context = canvas.getContext('2d');
	                context.drawImage(image, 0, 0, width, height);
	                console.warn('THREE.WebGLRenderer: Texture has been resized from (' + dimensions.width + 'x' + dimensions.height + ') to (' + width + 'x' + height + ').');
	                return canvas;
	            } else {
	                if ('data' in image) {
	                    console.warn('THREE.WebGLRenderer: Image in DataTexture is too big (' + dimensions.width + 'x' + dimensions.height + ').');
	                }
	                return image;
	            }
	        }
	        return image;
	    }
	    function textureNeedsGenerateMipmaps(texture) {
	        return texture.generateMipmaps;
	    }
	    function generateMipmap(target) {
	        _gl.generateMipmap(target);
	    }
	    function getTargetType(texture) {
	        if (texture.isWebGLCubeRenderTarget) return _gl.TEXTURE_CUBE_MAP;
	        if (texture.isWebGL3DRenderTarget) return _gl.TEXTURE_3D;
	        if (texture.isWebGLArrayRenderTarget || texture.isCompressedArrayTexture) return _gl.TEXTURE_2D_ARRAY;
	        return _gl.TEXTURE_2D;
	    }
	    function getInternalFormat(internalFormatName, glFormat, glType, colorSpace, forceLinearTransfer = false) {
	        if (internalFormatName !== null) {
	            if (_gl[internalFormatName] !== undefined) return _gl[internalFormatName];
	            console.warn('THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format \'' + internalFormatName + '\'');
	        }
	        let internalFormat = glFormat;
	        if (glFormat === _gl.RED) {
	            if (glType === _gl.FLOAT) internalFormat = _gl.R32F;
	            if (glType === _gl.HALF_FLOAT) internalFormat = _gl.R16F;
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.R8;
	        }
	        if (glFormat === _gl.RED_INTEGER) {
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.R8UI;
	            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.R16UI;
	            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.R32UI;
	            if (glType === _gl.BYTE) internalFormat = _gl.R8I;
	            if (glType === _gl.SHORT) internalFormat = _gl.R16I;
	            if (glType === _gl.INT) internalFormat = _gl.R32I;
	        }
	        if (glFormat === _gl.RG) {
	            if (glType === _gl.FLOAT) internalFormat = _gl.RG32F;
	            if (glType === _gl.HALF_FLOAT) internalFormat = _gl.RG16F;
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RG8;
	        }
	        if (glFormat === _gl.RG_INTEGER) {
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RG8UI;
	            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RG16UI;
	            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RG32UI;
	            if (glType === _gl.BYTE) internalFormat = _gl.RG8I;
	            if (glType === _gl.SHORT) internalFormat = _gl.RG16I;
	            if (glType === _gl.INT) internalFormat = _gl.RG32I;
	        }
	        if (glFormat === _gl.RGB_INTEGER) {
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RGB8UI;
	            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RGB16UI;
	            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RGB32UI;
	            if (glType === _gl.BYTE) internalFormat = _gl.RGB8I;
	            if (glType === _gl.SHORT) internalFormat = _gl.RGB16I;
	            if (glType === _gl.INT) internalFormat = _gl.RGB32I;
	        }
	        if (glFormat === _gl.RGBA_INTEGER) {
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RGBA8UI;
	            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RGBA16UI;
	            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RGBA32UI;
	            if (glType === _gl.BYTE) internalFormat = _gl.RGBA8I;
	            if (glType === _gl.SHORT) internalFormat = _gl.RGBA16I;
	            if (glType === _gl.INT) internalFormat = _gl.RGBA32I;
	        }
	        if (glFormat === _gl.RGB) {
	            if (glType === _gl.UNSIGNED_INT_5_9_9_9_REV) internalFormat = _gl.RGB9_E5;
	        }
	        if (glFormat === _gl.RGBA) {
	            const transfer = forceLinearTransfer ? LinearTransfer : ColorManagement.getTransfer(colorSpace);
	            if (glType === _gl.FLOAT) internalFormat = _gl.RGBA32F;
	            if (glType === _gl.HALF_FLOAT) internalFormat = _gl.RGBA16F;
	            if (glType === _gl.UNSIGNED_BYTE) internalFormat = transfer === SRGBTransfer ? _gl.SRGB8_ALPHA8 : _gl.RGBA8;
	            if (glType === _gl.UNSIGNED_SHORT_4_4_4_4) internalFormat = _gl.RGBA4;
	            if (glType === _gl.UNSIGNED_SHORT_5_5_5_1) internalFormat = _gl.RGB5_A1;
	        }
	        if (internalFormat === _gl.R16F || internalFormat === _gl.R32F || internalFormat === _gl.RG16F || internalFormat === _gl.RG32F || internalFormat === _gl.RGBA16F || internalFormat === _gl.RGBA32F) {
	            extensions.get('EXT_color_buffer_float');
	        }
	        return internalFormat;
	    }
	    function getInternalDepthFormat(useStencil, depthType) {
	        let glInternalFormat;
	        if (useStencil) {
	            if (depthType === null || depthType === UnsignedIntType || depthType === UnsignedInt248Type) {
	                glInternalFormat = _gl.DEPTH24_STENCIL8;
	            } else if (depthType === FloatType) {
	                glInternalFormat = _gl.DEPTH32F_STENCIL8;
	            } else if (depthType === UnsignedShortType) {
	                glInternalFormat = _gl.DEPTH24_STENCIL8;
	                console.warn('DepthTexture: 16 bit depth attachment is not supported with stencil. Using 24-bit attachment.');
	            }
	        } else {
	            if (depthType === null || depthType === UnsignedIntType || depthType === UnsignedInt248Type) {
	                glInternalFormat = _gl.DEPTH_COMPONENT24;
	            } else if (depthType === FloatType) {
	                glInternalFormat = _gl.DEPTH_COMPONENT32F;
	            } else if (depthType === UnsignedShortType) {
	                glInternalFormat = _gl.DEPTH_COMPONENT16;
	            }
	        }
	        return glInternalFormat;
	    }
	    function getMipLevels(texture, image) {
	        if (textureNeedsGenerateMipmaps(texture) === true || texture.isFramebufferTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter) {
	            return Math.log2(Math.max(image.width, image.height)) + 1;
	        } else if (texture.mipmaps !== undefined && texture.mipmaps.length > 0) {
	            // user-defined mipmaps
	            return texture.mipmaps.length;
	        } else if (texture.isCompressedTexture && Array.isArray(texture.image)) {
	            return image.mipmaps.length;
	        } else {
	            // texture without mipmaps (only base level)
	            return 1;
	        }
	    }
	    //
	    function onTextureDispose(event) {
	        const texture = event.target;
	        texture.removeEventListener('dispose', onTextureDispose);
	        deallocateTexture(texture);
	        if (texture.isVideoTexture) {
	            _videoTextures.delete(texture);
	        }
	    }
	    function onRenderTargetDispose(event) {
	        const renderTarget = event.target;
	        renderTarget.removeEventListener('dispose', onRenderTargetDispose);
	        deallocateRenderTarget(renderTarget);
	    }
	    //
	    function deallocateTexture(texture) {
	        const textureProperties = properties.get(texture);
	        if (textureProperties.__webglInit === undefined) return;
	        // check if it's necessary to remove the WebGLTexture object
	        const source = texture.source;
	        const webglTextures = _sources.get(source);
	        if (webglTextures) {
	            const webglTexture = webglTextures[textureProperties.__cacheKey];
	            webglTexture.usedTimes--;
	            // the WebGLTexture object is not used anymore, remove it
	            if (webglTexture.usedTimes === 0) {
	                deleteTexture(texture);
	            }
	            // remove the weak map entry if no WebGLTexture uses the source anymore
	            if (Object.keys(webglTextures).length === 0) {
	                _sources.delete(source);
	            }
	        }
	        properties.remove(texture);
	    }
	    function deleteTexture(texture) {
	        const textureProperties = properties.get(texture);
	        _gl.deleteTexture(textureProperties.__webglTexture);
	        const source = texture.source;
	        const webglTextures = _sources.get(source);
	        delete webglTextures[textureProperties.__cacheKey];
	        info.memory.textures--;
	    }
	    function deallocateRenderTarget(renderTarget) {
	        const renderTargetProperties = properties.get(renderTarget);
	        if (renderTarget.depthTexture) {
	            renderTarget.depthTexture.dispose();
	            properties.remove(renderTarget.depthTexture);
	        }
	        if (renderTarget.isWebGLCubeRenderTarget) {
	            for(let i = 0; i < 6; i++){
	                if (Array.isArray(renderTargetProperties.__webglFramebuffer[i])) {
	                    for(let level = 0; level < renderTargetProperties.__webglFramebuffer[i].length; level++)_gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i][level]);
	                } else {
	                    _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i]);
	                }
	                if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer[i]);
	            }
	        } else {
	            if (Array.isArray(renderTargetProperties.__webglFramebuffer)) {
	                for(let level = 0; level < renderTargetProperties.__webglFramebuffer.length; level++)_gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[level]);
	            } else {
	                _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer);
	            }
	            if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer);
	            if (renderTargetProperties.__webglMultisampledFramebuffer) _gl.deleteFramebuffer(renderTargetProperties.__webglMultisampledFramebuffer);
	            if (renderTargetProperties.__webglColorRenderbuffer) {
	                for(let i = 0; i < renderTargetProperties.__webglColorRenderbuffer.length; i++){
	                    if (renderTargetProperties.__webglColorRenderbuffer[i]) _gl.deleteRenderbuffer(renderTargetProperties.__webglColorRenderbuffer[i]);
	                }
	            }
	            if (renderTargetProperties.__webglDepthRenderbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthRenderbuffer);
	        }
	        const textures = renderTarget.textures;
	        for(let i = 0, il = textures.length; i < il; i++){
	            const attachmentProperties = properties.get(textures[i]);
	            if (attachmentProperties.__webglTexture) {
	                _gl.deleteTexture(attachmentProperties.__webglTexture);
	                info.memory.textures--;
	            }
	            properties.remove(textures[i]);
	        }
	        properties.remove(renderTarget);
	    }
	    //
	    let textureUnits = 0;
	    function resetTextureUnits() {
	        textureUnits = 0;
	    }
	    function allocateTextureUnit() {
	        const textureUnit = textureUnits;
	        if (textureUnit >= capabilities.maxTextures) {
	            console.warn('THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures);
	        }
	        textureUnits += 1;
	        return textureUnit;
	    }
	    function getTextureCacheKey(texture) {
	        const array = [];
	        array.push(texture.wrapS);
	        array.push(texture.wrapT);
	        array.push(texture.wrapR || 0);
	        array.push(texture.magFilter);
	        array.push(texture.minFilter);
	        array.push(texture.anisotropy);
	        array.push(texture.internalFormat);
	        array.push(texture.format);
	        array.push(texture.type);
	        array.push(texture.generateMipmaps);
	        array.push(texture.premultiplyAlpha);
	        array.push(texture.flipY);
	        array.push(texture.unpackAlignment);
	        array.push(texture.colorSpace);
	        return array.join();
	    }
	    //
	    function setTexture2D(texture, slot) {
	        const textureProperties = properties.get(texture);
	        if (texture.isVideoTexture) updateVideoTexture(texture);
	        if (texture.isRenderTargetTexture === false && texture.version > 0 && textureProperties.__version !== texture.version) {
	            const image = texture.image;
	            if (image === null) {
	                console.warn('THREE.WebGLRenderer: Texture marked for update but no image data found.');
	            } else if (image.complete === false) {
	                console.warn('THREE.WebGLRenderer: Texture marked for update but image is incomplete');
	            } else {
	                uploadTexture(textureProperties, texture, slot);
	                return;
	            }
	        }
	        state.bindTexture(_gl.TEXTURE_2D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
	    }
	    function setTexture2DArray(texture, slot) {
	        const textureProperties = properties.get(texture);
	        if (texture.version > 0 && textureProperties.__version !== texture.version) {
	            uploadTexture(textureProperties, texture, slot);
	            return;
	        }
	        state.bindTexture(_gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
	    }
	    function setTexture3D(texture, slot) {
	        const textureProperties = properties.get(texture);
	        if (texture.version > 0 && textureProperties.__version !== texture.version) {
	            uploadTexture(textureProperties, texture, slot);
	            return;
	        }
	        state.bindTexture(_gl.TEXTURE_3D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
	    }
	    function setTextureCube(texture, slot) {
	        const textureProperties = properties.get(texture);
	        if (texture.version > 0 && textureProperties.__version !== texture.version) {
	            uploadCubeTexture(textureProperties, texture, slot);
	            return;
	        }
	        state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
	    }
	    const wrappingToGL = {
	        [RepeatWrapping]: _gl.REPEAT,
	        [ClampToEdgeWrapping]: _gl.CLAMP_TO_EDGE,
	        [MirroredRepeatWrapping]: _gl.MIRRORED_REPEAT
	    };
	    const filterToGL = {
	        [NearestFilter]: _gl.NEAREST,
	        [NearestMipmapNearestFilter]: _gl.NEAREST_MIPMAP_NEAREST,
	        [NearestMipmapLinearFilter]: _gl.NEAREST_MIPMAP_LINEAR,
	        [LinearFilter]: _gl.LINEAR,
	        [LinearMipmapNearestFilter]: _gl.LINEAR_MIPMAP_NEAREST,
	        [LinearMipmapLinearFilter]: _gl.LINEAR_MIPMAP_LINEAR
	    };
	    const compareToGL = {
	        [NeverCompare]: _gl.NEVER,
	        [AlwaysCompare]: _gl.ALWAYS,
	        [LessCompare]: _gl.LESS,
	        [LessEqualCompare]: _gl.LEQUAL,
	        [EqualCompare]: _gl.EQUAL,
	        [GreaterEqualCompare]: _gl.GEQUAL,
	        [GreaterCompare]: _gl.GREATER,
	        [NotEqualCompare]: _gl.NOTEQUAL
	    };
	    function setTextureParameters(textureType, texture) {
	        if (texture.type === FloatType && extensions.has('OES_texture_float_linear') === false && (texture.magFilter === LinearFilter || texture.magFilter === LinearMipmapNearestFilter || texture.magFilter === NearestMipmapLinearFilter || texture.magFilter === LinearMipmapLinearFilter || texture.minFilter === LinearFilter || texture.minFilter === LinearMipmapNearestFilter || texture.minFilter === NearestMipmapLinearFilter || texture.minFilter === LinearMipmapLinearFilter)) {
	            console.warn('THREE.WebGLRenderer: Unable to use linear filtering with floating point textures. OES_texture_float_linear not supported on this device.');
	        }
	        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_S, wrappingToGL[texture.wrapS]);
	        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_T, wrappingToGL[texture.wrapT]);
	        if (textureType === _gl.TEXTURE_3D || textureType === _gl.TEXTURE_2D_ARRAY) {
	            _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_R, wrappingToGL[texture.wrapR]);
	        }
	        _gl.texParameteri(textureType, _gl.TEXTURE_MAG_FILTER, filterToGL[texture.magFilter]);
	        _gl.texParameteri(textureType, _gl.TEXTURE_MIN_FILTER, filterToGL[texture.minFilter]);
	        if (texture.compareFunction) {
	            _gl.texParameteri(textureType, _gl.TEXTURE_COMPARE_MODE, _gl.COMPARE_REF_TO_TEXTURE);
	            _gl.texParameteri(textureType, _gl.TEXTURE_COMPARE_FUNC, compareToGL[texture.compareFunction]);
	        }
	        if (extensions.has('EXT_texture_filter_anisotropic') === true) {
	            if (texture.magFilter === NearestFilter) return;
	            if (texture.minFilter !== NearestMipmapLinearFilter && texture.minFilter !== LinearMipmapLinearFilter) return;
	            if (texture.type === FloatType && extensions.has('OES_texture_float_linear') === false) return; // verify extension
	            if (texture.anisotropy > 1 || properties.get(texture).__currentAnisotropy) {
	                const extension = extensions.get('EXT_texture_filter_anisotropic');
	                _gl.texParameterf(textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(texture.anisotropy, capabilities.getMaxAnisotropy()));
	                properties.get(texture).__currentAnisotropy = texture.anisotropy;
	            }
	        }
	    }
	    function initTexture(textureProperties, texture) {
	        let forceUpload = false;
	        if (textureProperties.__webglInit === undefined) {
	            textureProperties.__webglInit = true;
	            texture.addEventListener('dispose', onTextureDispose);
	        }
	        // create Source <-> WebGLTextures mapping if necessary
	        const source = texture.source;
	        let webglTextures = _sources.get(source);
	        if (webglTextures === undefined) {
	            webglTextures = {};
	            _sources.set(source, webglTextures);
	        }
	        // check if there is already a WebGLTexture object for the given texture parameters
	        const textureCacheKey = getTextureCacheKey(texture);
	        if (textureCacheKey !== textureProperties.__cacheKey) {
	            // if not, create a new instance of WebGLTexture
	            if (webglTextures[textureCacheKey] === undefined) {
	                // create new entry
	                webglTextures[textureCacheKey] = {
	                    texture: _gl.createTexture(),
	                    usedTimes: 0
	                };
	                info.memory.textures++;
	                // when a new instance of WebGLTexture was created, a texture upload is required
	                // even if the image contents are identical
	                forceUpload = true;
	            }
	            webglTextures[textureCacheKey].usedTimes++;
	            // every time the texture cache key changes, it's necessary to check if an instance of
	            // WebGLTexture can be deleted in order to avoid a memory leak.
	            const webglTexture = webglTextures[textureProperties.__cacheKey];
	            if (webglTexture !== undefined) {
	                webglTextures[textureProperties.__cacheKey].usedTimes--;
	                if (webglTexture.usedTimes === 0) {
	                    deleteTexture(texture);
	                }
	            }
	            // store references to cache key and WebGLTexture object
	            textureProperties.__cacheKey = textureCacheKey;
	            textureProperties.__webglTexture = webglTextures[textureCacheKey].texture;
	        }
	        return forceUpload;
	    }
	    function uploadTexture(textureProperties, texture, slot) {
	        let textureType = _gl.TEXTURE_2D;
	        if (texture.isDataArrayTexture || texture.isCompressedArrayTexture) textureType = _gl.TEXTURE_2D_ARRAY;
	        if (texture.isData3DTexture) textureType = _gl.TEXTURE_3D;
	        const forceUpload = initTexture(textureProperties, texture);
	        const source = texture.source;
	        state.bindTexture(textureType, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
	        const sourceProperties = properties.get(source);
	        if (source.version !== sourceProperties.__version || forceUpload === true) {
	            state.activeTexture(_gl.TEXTURE0 + slot);
	            const workingPrimaries = ColorManagement.getPrimaries(ColorManagement.workingColorSpace);
	            const texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries(texture.colorSpace);
	            const unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;
	            _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY);
	            _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha);
	            _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment);
	            _gl.pixelStorei(_gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion);
	            let image = resizeImage(texture.image, false, capabilities.maxTextureSize);
	            image = verifyColorSpace(texture, image);
	            const glFormat = utils.convert(texture.format, texture.colorSpace);
	            const glType = utils.convert(texture.type);
	            let glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace, texture.isVideoTexture);
	            setTextureParameters(textureType, texture);
	            let mipmap;
	            const mipmaps = texture.mipmaps;
	            const useTexStorage = texture.isVideoTexture !== true;
	            const allocateMemory = sourceProperties.__version === undefined || forceUpload === true;
	            const dataReady = source.dataReady;
	            const levels = getMipLevels(texture, image);
	            if (texture.isDepthTexture) {
	                glInternalFormat = getInternalDepthFormat(texture.format === DepthStencilFormat, texture.type);
	                //
	                if (allocateMemory) {
	                    if (useTexStorage) {
	                        state.texStorage2D(_gl.TEXTURE_2D, 1, glInternalFormat, image.width, image.height);
	                    } else {
	                        state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null);
	                    }
	                }
	            } else if (texture.isDataTexture) {
	                // use manually created mipmaps if available
	                // if there are no manual mipmaps
	                // set 0 level mipmap and then use GL to generate other mipmap levels
	                if (mipmaps.length > 0) {
	                    if (useTexStorage && allocateMemory) {
	                        state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height);
	                    }
	                    for(let i = 0, il = mipmaps.length; i < il; i++){
	                        mipmap = mipmaps[i];
	                        if (useTexStorage) {
	                            if (dataReady) {
	                                state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
	                            }
	                        } else {
	                            state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data);
	                        }
	                    }
	                    texture.generateMipmaps = false;
	                } else {
	                    if (useTexStorage) {
	                        if (allocateMemory) {
	                            state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height);
	                        }
	                        if (dataReady) {
	                            state.texSubImage2D(_gl.TEXTURE_2D, 0, 0, 0, image.width, image.height, glFormat, glType, image.data);
	                        }
	                    } else {
	                        state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data);
	                    }
	                }
	            } else if (texture.isCompressedTexture) {
	                if (texture.isCompressedArrayTexture) {
	                    if (useTexStorage && allocateMemory) {
	                        state.texStorage3D(_gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height, image.depth);
	                    }
	                    for(let i = 0, il = mipmaps.length; i < il; i++){
	                        mipmap = mipmaps[i];
	                        if (texture.format !== RGBAFormat) {
	                            if (glFormat !== null) {
	                                if (useTexStorage) {
	                                    if (dataReady) {
	                                        if (texture.layerUpdates.size > 0) {
	                                            const layerByteLength = getByteLength(mipmap.width, mipmap.height, texture.format, texture.type);
	                                            for (const layerIndex of texture.layerUpdates){
	                                                const layerData = mipmap.data.subarray(layerIndex * layerByteLength / mipmap.data.BYTES_PER_ELEMENT, (layerIndex + 1) * layerByteLength / mipmap.data.BYTES_PER_ELEMENT);
	                                                state.compressedTexSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, layerIndex, mipmap.width, mipmap.height, 1, glFormat, layerData);
	                                            }
	                                            texture.clearLayerUpdates();
	                                        } else {
	                                            state.compressedTexSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, mipmap.data);
	                                        }
	                                    }
	                                } else {
	                                    state.compressedTexImage3D(_gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, mipmap.data, 0, 0);
	                                }
	                            } else {
	                                console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()');
	                            }
	                        } else {
	                            if (useTexStorage) {
	                                if (dataReady) {
	                                    state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, glType, mipmap.data);
	                                }
	                            } else {
	                                state.texImage3D(_gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, glFormat, glType, mipmap.data);
	                            }
	                        }
	                    }
	                } else {
	                    if (useTexStorage && allocateMemory) {
	                        state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height);
	                    }
	                    for(let i = 0, il = mipmaps.length; i < il; i++){
	                        mipmap = mipmaps[i];
	                        if (texture.format !== RGBAFormat) {
	                            if (glFormat !== null) {
	                                if (useTexStorage) {
	                                    if (dataReady) {
	                                        state.compressedTexSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data);
	                                    }
	                                } else {
	                                    state.compressedTexImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data);
	                                }
	                            } else {
	                                console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()');
	                            }
	                        } else {
	                            if (useTexStorage) {
	                                if (dataReady) {
	                                    state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
	                                }
	                            } else {
	                                state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data);
	                            }
	                        }
	                    }
	                }
	            } else if (texture.isDataArrayTexture) {
	                if (useTexStorage) {
	                    if (allocateMemory) {
	                        state.texStorage3D(_gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, image.width, image.height, image.depth);
	                    }
	                    if (dataReady) {
	                        if (texture.layerUpdates.size > 0) {
	                            const layerByteLength = getByteLength(image.width, image.height, texture.format, texture.type);
	                            for (const layerIndex of texture.layerUpdates){
	                                const layerData = image.data.subarray(layerIndex * layerByteLength / image.data.BYTES_PER_ELEMENT, (layerIndex + 1) * layerByteLength / image.data.BYTES_PER_ELEMENT);
	                                state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, 0, 0, 0, layerIndex, image.width, image.height, 1, glFormat, glType, layerData);
	                            }
	                            texture.clearLayerUpdates();
	                        } else {
	                            state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data);
	                        }
	                    }
	                } else {
	                    state.texImage3D(_gl.TEXTURE_2D_ARRAY, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data);
	                }
	            } else if (texture.isData3DTexture) {
	                if (useTexStorage) {
	                    if (allocateMemory) {
	                        state.texStorage3D(_gl.TEXTURE_3D, levels, glInternalFormat, image.width, image.height, image.depth);
	                    }
	                    if (dataReady) {
	                        state.texSubImage3D(_gl.TEXTURE_3D, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data);
	                    }
	                } else {
	                    state.texImage3D(_gl.TEXTURE_3D, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data);
	                }
	            } else if (texture.isFramebufferTexture) {
	                if (allocateMemory) {
	                    if (useTexStorage) {
	                        state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height);
	                    } else {
	                        let width = image.width, height = image.height;
	                        for(let i = 0; i < levels; i++){
	                            state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, width, height, 0, glFormat, glType, null);
	                            width >>= 1;
	                            height >>= 1;
	                        }
	                    }
	                }
	            } else {
	                // regular Texture (image, video, canvas)
	                // use manually created mipmaps if available
	                // if there are no manual mipmaps
	                // set 0 level mipmap and then use GL to generate other mipmap levels
	                if (mipmaps.length > 0) {
	                    if (useTexStorage && allocateMemory) {
	                        const dimensions = getDimensions(mipmaps[0]);
	                        state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height);
	                    }
	                    for(let i = 0, il = mipmaps.length; i < il; i++){
	                        mipmap = mipmaps[i];
	                        if (useTexStorage) {
	                            if (dataReady) {
	                                state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, glFormat, glType, mipmap);
	                            }
	                        } else {
	                            state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, glFormat, glType, mipmap);
	                        }
	                    }
	                    texture.generateMipmaps = false;
	                } else {
	                    if (useTexStorage) {
	                        if (allocateMemory) {
	                            const dimensions = getDimensions(image);
	                            state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height);
	                        }
	                        if (dataReady) {
	                            state.texSubImage2D(_gl.TEXTURE_2D, 0, 0, 0, glFormat, glType, image);
	                        }
	                    } else {
	                        state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, glFormat, glType, image);
	                    }
	                }
	            }
	            if (textureNeedsGenerateMipmaps(texture)) {
	                generateMipmap(textureType);
	            }
	            sourceProperties.__version = source.version;
	            if (texture.onUpdate) texture.onUpdate(texture);
	        }
	        textureProperties.__version = texture.version;
	    }
	    function uploadCubeTexture(textureProperties, texture, slot) {
	        if (texture.image.length !== 6) return;
	        const forceUpload = initTexture(textureProperties, texture);
	        const source = texture.source;
	        state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
	        const sourceProperties = properties.get(source);
	        if (source.version !== sourceProperties.__version || forceUpload === true) {
	            state.activeTexture(_gl.TEXTURE0 + slot);
	            const workingPrimaries = ColorManagement.getPrimaries(ColorManagement.workingColorSpace);
	            const texturePrimaries = texture.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries(texture.colorSpace);
	            const unpackConversion = texture.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;
	            _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY);
	            _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha);
	            _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment);
	            _gl.pixelStorei(_gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion);
	            const isCompressed = texture.isCompressedTexture || texture.image[0].isCompressedTexture;
	            const isDataTexture = texture.image[0] && texture.image[0].isDataTexture;
	            const cubeImage = [];
	            for(let i = 0; i < 6; i++){
	                if (!isCompressed && !isDataTexture) {
	                    cubeImage[i] = resizeImage(texture.image[i], true, capabilities.maxCubemapSize);
	                } else {
	                    cubeImage[i] = isDataTexture ? texture.image[i].image : texture.image[i];
	                }
	                cubeImage[i] = verifyColorSpace(texture, cubeImage[i]);
	            }
	            const image = cubeImage[0], glFormat = utils.convert(texture.format, texture.colorSpace), glType = utils.convert(texture.type), glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace);
	            const useTexStorage = texture.isVideoTexture !== true;
	            const allocateMemory = sourceProperties.__version === undefined || forceUpload === true;
	            const dataReady = source.dataReady;
	            let levels = getMipLevels(texture, image);
	            setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture);
	            let mipmaps;
	            if (isCompressed) {
	                if (useTexStorage && allocateMemory) {
	                    state.texStorage2D(_gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, image.width, image.height);
	                }
	                for(let i = 0; i < 6; i++){
	                    mipmaps = cubeImage[i].mipmaps;
	                    for(let j = 0; j < mipmaps.length; j++){
	                        const mipmap = mipmaps[j];
	                        if (texture.format !== RGBAFormat) {
	                            if (glFormat !== null) {
	                                if (useTexStorage) {
	                                    if (dataReady) {
	                                        state.compressedTexSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data);
	                                    }
	                                } else {
	                                    state.compressedTexImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data);
	                                }
	                            } else {
	                                console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()');
	                            }
	                        } else {
	                            if (useTexStorage) {
	                                if (dataReady) {
	                                    state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
	                                }
	                            } else {
	                                state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data);
	                            }
	                        }
	                    }
	                }
	            } else {
	                mipmaps = texture.mipmaps;
	                if (useTexStorage && allocateMemory) {
	                    // TODO: Uniformly handle mipmap definitions
	                    // Normal textures and compressed cube textures define base level + mips with their mipmap array
	                    // Uncompressed cube textures use their mipmap array only for mips (no base level)
	                    if (mipmaps.length > 0) levels++;
	                    const dimensions = getDimensions(cubeImage[0]);
	                    state.texStorage2D(_gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, dimensions.width, dimensions.height);
	                }
	                for(let i = 0; i < 6; i++){
	                    if (isDataTexture) {
	                        if (useTexStorage) {
	                            if (dataReady) {
	                                state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, cubeImage[i].width, cubeImage[i].height, glFormat, glType, cubeImage[i].data);
	                            }
	                        } else {
	                            state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, cubeImage[i].width, cubeImage[i].height, 0, glFormat, glType, cubeImage[i].data);
	                        }
	                        for(let j = 0; j < mipmaps.length; j++){
	                            const mipmap = mipmaps[j];
	                            const mipmapImage = mipmap.image[i].image;
	                            if (useTexStorage) {
	                                if (dataReady) {
	                                    state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, mipmapImage.width, mipmapImage.height, glFormat, glType, mipmapImage.data);
	                                }
	                            } else {
	                                state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data);
	                            }
	                        }
	                    } else {
	                        if (useTexStorage) {
	                            if (dataReady) {
	                                state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, glFormat, glType, cubeImage[i]);
	                            }
	                        } else {
	                            state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, glFormat, glType, cubeImage[i]);
	                        }
	                        for(let j = 0; j < mipmaps.length; j++){
	                            const mipmap = mipmaps[j];
	                            if (useTexStorage) {
	                                if (dataReady) {
	                                    state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, glFormat, glType, mipmap.image[i]);
	                                }
	                            } else {
	                                state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[i]);
	                            }
	                        }
	                    }
	                }
	            }
	            if (textureNeedsGenerateMipmaps(texture)) {
	                // We assume images for cube map have the same size.
	                generateMipmap(_gl.TEXTURE_CUBE_MAP);
	            }
	            sourceProperties.__version = source.version;
	            if (texture.onUpdate) texture.onUpdate(texture);
	        }
	        textureProperties.__version = texture.version;
	    }
	    // Render targets
	    // Setup storage for target texture and bind it to correct framebuffer
	    function setupFrameBufferTexture(framebuffer, renderTarget, texture, attachment, textureTarget, level) {
	        const glFormat = utils.convert(texture.format, texture.colorSpace);
	        const glType = utils.convert(texture.type);
	        const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace);
	        const renderTargetProperties = properties.get(renderTarget);
	        const textureProperties = properties.get(texture);
	        textureProperties.__renderTarget = renderTarget;
	        if (!renderTargetProperties.__hasExternalTextures) {
	            const width = Math.max(1, renderTarget.width >> level);
	            const height = Math.max(1, renderTarget.height >> level);
	            if (textureTarget === _gl.TEXTURE_3D || textureTarget === _gl.TEXTURE_2D_ARRAY) {
	                state.texImage3D(textureTarget, level, glInternalFormat, width, height, renderTarget.depth, 0, glFormat, glType, null);
	            } else {
	                state.texImage2D(textureTarget, level, glInternalFormat, width, height, 0, glFormat, glType, null);
	            }
	        }
	        state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
	        if (useMultisampledRTT(renderTarget)) {
	            multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, attachment, textureTarget, textureProperties.__webglTexture, 0, getRenderTargetSamples(renderTarget));
	        } else if (textureTarget === _gl.TEXTURE_2D || textureTarget >= _gl.TEXTURE_CUBE_MAP_POSITIVE_X && textureTarget <= _gl.TEXTURE_CUBE_MAP_NEGATIVE_Z) {
	            _gl.framebufferTexture2D(_gl.FRAMEBUFFER, attachment, textureTarget, textureProperties.__webglTexture, level);
	        }
	        state.bindFramebuffer(_gl.FRAMEBUFFER, null);
	    }
	    // Setup storage for internal depth/stencil buffers and bind to correct framebuffer
	    function setupRenderBufferStorage(renderbuffer, renderTarget, isMultisample) {
	        _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer);
	        if (renderTarget.depthBuffer) {
	            // retrieve the depth attachment types
	            const depthTexture = renderTarget.depthTexture;
	            const depthType = depthTexture && depthTexture.isDepthTexture ? depthTexture.type : null;
	            const glInternalFormat = getInternalDepthFormat(renderTarget.stencilBuffer, depthType);
	            const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
	            // set up the attachment
	            const samples = getRenderTargetSamples(renderTarget);
	            const isUseMultisampledRTT = useMultisampledRTT(renderTarget);
	            if (isUseMultisampledRTT) {
	                multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
	            } else if (isMultisample) {
	                _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
	            } else {
	                _gl.renderbufferStorage(_gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height);
	            }
	            _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer);
	        } else {
	            const textures = renderTarget.textures;
	            for(let i = 0; i < textures.length; i++){
	                const texture = textures[i];
	                const glFormat = utils.convert(texture.format, texture.colorSpace);
	                const glType = utils.convert(texture.type);
	                const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace);
	                const samples = getRenderTargetSamples(renderTarget);
	                if (isMultisample && useMultisampledRTT(renderTarget) === false) {
	                    _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
	                } else if (useMultisampledRTT(renderTarget)) {
	                    multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
	                } else {
	                    _gl.renderbufferStorage(_gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height);
	                }
	            }
	        }
	        _gl.bindRenderbuffer(_gl.RENDERBUFFER, null);
	    }
	    // Setup resources for a Depth Texture for a FBO (needs an extension)
	    function setupDepthTexture(framebuffer, renderTarget) {
	        const isCube = renderTarget && renderTarget.isWebGLCubeRenderTarget;
	        if (isCube) throw new Error('Depth Texture with cube render targets is not supported');
	        state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
	        if (!(renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture)) {
	            throw new Error('renderTarget.depthTexture must be an instance of THREE.DepthTexture');
	        }
	        const textureProperties = properties.get(renderTarget.depthTexture);
	        textureProperties.__renderTarget = renderTarget;
	        // upload an empty depth texture with framebuffer size
	        if (!textureProperties.__webglTexture || renderTarget.depthTexture.image.width !== renderTarget.width || renderTarget.depthTexture.image.height !== renderTarget.height) {
	            renderTarget.depthTexture.image.width = renderTarget.width;
	            renderTarget.depthTexture.image.height = renderTarget.height;
	            renderTarget.depthTexture.needsUpdate = true;
	        }
	        setTexture2D(renderTarget.depthTexture, 0);
	        const webglDepthTexture = textureProperties.__webglTexture;
	        const samples = getRenderTargetSamples(renderTarget);
	        if (renderTarget.depthTexture.format === DepthFormat) {
	            if (useMultisampledRTT(renderTarget)) {
	                multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples);
	            } else {
	                _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0);
	            }
	        } else if (renderTarget.depthTexture.format === DepthStencilFormat) {
	            if (useMultisampledRTT(renderTarget)) {
	                multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples);
	            } else {
	                _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0);
	            }
	        } else {
	            throw new Error('Unknown depthTexture format');
	        }
	    }
	    // Setup GL resources for a non-texture depth buffer
	    function setupDepthRenderbuffer(renderTarget) {
	        const renderTargetProperties = properties.get(renderTarget);
	        const isCube = renderTarget.isWebGLCubeRenderTarget === true;
	        // if the bound depth texture has changed
	        if (renderTargetProperties.__boundDepthTexture !== renderTarget.depthTexture) {
	            // fire the dispose event to get rid of stored state associated with the previously bound depth buffer
	            const depthTexture = renderTarget.depthTexture;
	            if (renderTargetProperties.__depthDisposeCallback) {
	                renderTargetProperties.__depthDisposeCallback();
	            }
	            // set up dispose listeners to track when the currently attached buffer is implicitly unbound
	            if (depthTexture) {
	                const disposeEvent = ()=>{
	                    delete renderTargetProperties.__boundDepthTexture;
	                    delete renderTargetProperties.__depthDisposeCallback;
	                    depthTexture.removeEventListener('dispose', disposeEvent);
	                };
	                depthTexture.addEventListener('dispose', disposeEvent);
	                renderTargetProperties.__depthDisposeCallback = disposeEvent;
	            }
	            renderTargetProperties.__boundDepthTexture = depthTexture;
	        }
	        if (renderTarget.depthTexture && !renderTargetProperties.__autoAllocateDepthBuffer) {
	            if (isCube) throw new Error('target.depthTexture not supported in Cube render targets');
	            setupDepthTexture(renderTargetProperties.__webglFramebuffer, renderTarget);
	        } else {
	            if (isCube) {
	                renderTargetProperties.__webglDepthbuffer = [];
	                for(let i = 0; i < 6; i++){
	                    state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[i]);
	                    if (renderTargetProperties.__webglDepthbuffer[i] === undefined) {
	                        renderTargetProperties.__webglDepthbuffer[i] = _gl.createRenderbuffer();
	                        setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer[i], renderTarget, false);
	                    } else {
	                        // attach buffer if it's been created already
	                        const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
	                        const renderbuffer = renderTargetProperties.__webglDepthbuffer[i];
	                        _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer);
	                        _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer);
	                    }
	                }
	            } else {
	                state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
	                if (renderTargetProperties.__webglDepthbuffer === undefined) {
	                    renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
	                    setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer, renderTarget, false);
	                } else {
	                    // attach buffer if it's been created already
	                    const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
	                    const renderbuffer = renderTargetProperties.__webglDepthbuffer;
	                    _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer);
	                    _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer);
	                }
	            }
	        }
	        state.bindFramebuffer(_gl.FRAMEBUFFER, null);
	    }
	    // rebind framebuffer with external textures
	    function rebindTextures(renderTarget, colorTexture, depthTexture) {
	        const renderTargetProperties = properties.get(renderTarget);
	        if (colorTexture !== undefined) {
	            setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, renderTarget.texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, 0);
	        }
	        if (depthTexture !== undefined) {
	            setupDepthRenderbuffer(renderTarget);
	        }
	    }
	    // Set up GL resources for the render target
	    function setupRenderTarget(renderTarget) {
	        const texture = renderTarget.texture;
	        const renderTargetProperties = properties.get(renderTarget);
	        const textureProperties = properties.get(texture);
	        renderTarget.addEventListener('dispose', onRenderTargetDispose);
	        const textures = renderTarget.textures;
	        const isCube = renderTarget.isWebGLCubeRenderTarget === true;
	        const isMultipleRenderTargets = textures.length > 1;
	        if (!isMultipleRenderTargets) {
	            if (textureProperties.__webglTexture === undefined) {
	                textureProperties.__webglTexture = _gl.createTexture();
	            }
	            textureProperties.__version = texture.version;
	            info.memory.textures++;
	        }
	        // Setup framebuffer
	        if (isCube) {
	            renderTargetProperties.__webglFramebuffer = [];
	            for(let i = 0; i < 6; i++){
	                if (texture.mipmaps && texture.mipmaps.length > 0) {
	                    renderTargetProperties.__webglFramebuffer[i] = [];
	                    for(let level = 0; level < texture.mipmaps.length; level++){
	                        renderTargetProperties.__webglFramebuffer[i][level] = _gl.createFramebuffer();
	                    }
	                } else {
	                    renderTargetProperties.__webglFramebuffer[i] = _gl.createFramebuffer();
	                }
	            }
	        } else {
	            if (texture.mipmaps && texture.mipmaps.length > 0) {
	                renderTargetProperties.__webglFramebuffer = [];
	                for(let level = 0; level < texture.mipmaps.length; level++){
	                    renderTargetProperties.__webglFramebuffer[level] = _gl.createFramebuffer();
	                }
	            } else {
	                renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();
	            }
	            if (isMultipleRenderTargets) {
	                for(let i = 0, il = textures.length; i < il; i++){
	                    const attachmentProperties = properties.get(textures[i]);
	                    if (attachmentProperties.__webglTexture === undefined) {
	                        attachmentProperties.__webglTexture = _gl.createTexture();
	                        info.memory.textures++;
	                    }
	                }
	            }
	            if (renderTarget.samples > 0 && useMultisampledRTT(renderTarget) === false) {
	                renderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer();
	                renderTargetProperties.__webglColorRenderbuffer = [];
	                state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
	                for(let i = 0; i < textures.length; i++){
	                    const texture = textures[i];
	                    renderTargetProperties.__webglColorRenderbuffer[i] = _gl.createRenderbuffer();
	                    _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
	                    const glFormat = utils.convert(texture.format, texture.colorSpace);
	                    const glType = utils.convert(texture.type);
	                    const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace, renderTarget.isXRRenderTarget === true);
	                    const samples = getRenderTargetSamples(renderTarget);
	                    _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
	                    _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
	                }
	                _gl.bindRenderbuffer(_gl.RENDERBUFFER, null);
	                if (renderTarget.depthBuffer) {
	                    renderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer();
	                    setupRenderBufferStorage(renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true);
	                }
	                state.bindFramebuffer(_gl.FRAMEBUFFER, null);
	            }
	        }
	        // Setup color buffer
	        if (isCube) {
	            state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture);
	            setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture);
	            for(let i = 0; i < 6; i++){
	                if (texture.mipmaps && texture.mipmaps.length > 0) {
	                    for(let level = 0; level < texture.mipmaps.length; level++){
	                        setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[i][level], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, level);
	                    }
	                } else {
	                    setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[i], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0);
	                }
	            }
	            if (textureNeedsGenerateMipmaps(texture)) {
	                generateMipmap(_gl.TEXTURE_CUBE_MAP);
	            }
	            state.unbindTexture();
	        } else if (isMultipleRenderTargets) {
	            for(let i = 0, il = textures.length; i < il; i++){
	                const attachment = textures[i];
	                const attachmentProperties = properties.get(attachment);
	                state.bindTexture(_gl.TEXTURE_2D, attachmentProperties.__webglTexture);
	                setTextureParameters(_gl.TEXTURE_2D, attachment);
	                setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, attachment, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, 0);
	                if (textureNeedsGenerateMipmaps(attachment)) {
	                    generateMipmap(_gl.TEXTURE_2D);
	                }
	            }
	            state.unbindTexture();
	        } else {
	            let glTextureType = _gl.TEXTURE_2D;
	            if (renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget) {
	                glTextureType = renderTarget.isWebGL3DRenderTarget ? _gl.TEXTURE_3D : _gl.TEXTURE_2D_ARRAY;
	            }
	            state.bindTexture(glTextureType, textureProperties.__webglTexture);
	            setTextureParameters(glTextureType, texture);
	            if (texture.mipmaps && texture.mipmaps.length > 0) {
	                for(let level = 0; level < texture.mipmaps.length; level++){
	                    setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[level], renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, level);
	                }
	            } else {
	                setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, 0);
	            }
	            if (textureNeedsGenerateMipmaps(texture)) {
	                generateMipmap(glTextureType);
	            }
	            state.unbindTexture();
	        }
	        // Setup depth and stencil buffers
	        if (renderTarget.depthBuffer) {
	            setupDepthRenderbuffer(renderTarget);
	        }
	    }
	    function updateRenderTargetMipmap(renderTarget) {
	        const textures = renderTarget.textures;
	        for(let i = 0, il = textures.length; i < il; i++){
	            const texture = textures[i];
	            if (textureNeedsGenerateMipmaps(texture)) {
	                const targetType = getTargetType(renderTarget);
	                const webglTexture = properties.get(texture).__webglTexture;
	                state.bindTexture(targetType, webglTexture);
	                generateMipmap(targetType);
	                state.unbindTexture();
	            }
	        }
	    }
	    const invalidationArrayRead = [];
	    const invalidationArrayDraw = [];
	    function updateMultisampleRenderTarget(renderTarget) {
	        if (renderTarget.samples > 0) {
	            if (useMultisampledRTT(renderTarget) === false) {
	                const textures = renderTarget.textures;
	                const width = renderTarget.width;
	                const height = renderTarget.height;
	                let mask = _gl.COLOR_BUFFER_BIT;
	                const depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
	                const renderTargetProperties = properties.get(renderTarget);
	                const isMultipleRenderTargets = textures.length > 1;
	                // If MRT we need to remove FBO attachments
	                if (isMultipleRenderTargets) {
	                    for(let i = 0; i < textures.length; i++){
	                        state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
	                        _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, null);
	                        state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
	                        _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, null, 0);
	                    }
	                }
	                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
	                for(let i = 0; i < textures.length; i++){
	                    if (renderTarget.resolveDepthBuffer) {
	                        if (renderTarget.depthBuffer) mask |= _gl.DEPTH_BUFFER_BIT;
	                        // resolving stencil is slow with a D3D backend. disable it for all transmission render targets (see #27799)
	                        if (renderTarget.stencilBuffer && renderTarget.resolveStencilBuffer) mask |= _gl.STENCIL_BUFFER_BIT;
	                    }
	                    if (isMultipleRenderTargets) {
	                        _gl.framebufferRenderbuffer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
	                        const webglTexture = properties.get(textures[i]).__webglTexture;
	                        _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, webglTexture, 0);
	                    }
	                    _gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, mask, _gl.NEAREST);
	                    if (supportsInvalidateFramebuffer === true) {
	                        invalidationArrayRead.length = 0;
	                        invalidationArrayDraw.length = 0;
	                        invalidationArrayRead.push(_gl.COLOR_ATTACHMENT0 + i);
	                        if (renderTarget.depthBuffer && renderTarget.resolveDepthBuffer === false) {
	                            invalidationArrayRead.push(depthStyle);
	                            invalidationArrayDraw.push(depthStyle);
	                            _gl.invalidateFramebuffer(_gl.DRAW_FRAMEBUFFER, invalidationArrayDraw);
	                        }
	                        _gl.invalidateFramebuffer(_gl.READ_FRAMEBUFFER, invalidationArrayRead);
	                    }
	                }
	                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null);
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null);
	                // If MRT since pre-blit we removed the FBO we need to reconstruct the attachments
	                if (isMultipleRenderTargets) {
	                    for(let i = 0; i < textures.length; i++){
	                        state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
	                        _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
	                        const webglTexture = properties.get(textures[i]).__webglTexture;
	                        state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
	                        _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, webglTexture, 0);
	                    }
	                }
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
	            } else {
	                if (renderTarget.depthBuffer && renderTarget.resolveDepthBuffer === false && supportsInvalidateFramebuffer) {
	                    const depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
	                    _gl.invalidateFramebuffer(_gl.DRAW_FRAMEBUFFER, [
	                        depthStyle
	                    ]);
	                }
	            }
	        }
	    }
	    function getRenderTargetSamples(renderTarget) {
	        return Math.min(capabilities.maxSamples, renderTarget.samples);
	    }
	    function useMultisampledRTT(renderTarget) {
	        const renderTargetProperties = properties.get(renderTarget);
	        return renderTarget.samples > 0 && extensions.has('WEBGL_multisampled_render_to_texture') === true && renderTargetProperties.__useRenderToTexture !== false;
	    }
	    function updateVideoTexture(texture) {
	        const frame = info.render.frame;
	        // Check the last frame we updated the VideoTexture
	        if (_videoTextures.get(texture) !== frame) {
	            _videoTextures.set(texture, frame);
	            texture.update();
	        }
	    }
	    function verifyColorSpace(texture, image) {
	        const colorSpace = texture.colorSpace;
	        const format = texture.format;
	        const type = texture.type;
	        if (texture.isCompressedTexture === true || texture.isVideoTexture === true) return image;
	        if (colorSpace !== LinearSRGBColorSpace && colorSpace !== NoColorSpace) {
	            // sRGB
	            if (ColorManagement.getTransfer(colorSpace) === SRGBTransfer) {
	                // in WebGL 2 uncompressed textures can only be sRGB encoded if they have the RGBA8 format
	                if (format !== RGBAFormat || type !== UnsignedByteType) {
	                    console.warn('THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType.');
	                }
	            } else {
	                console.error('THREE.WebGLTextures: Unsupported texture color space:', colorSpace);
	            }
	        }
	        return image;
	    }
	    function getDimensions(image) {
	        if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement) {
	            // if intrinsic data are not available, fallback to width/height
	            _imageDimensions.width = image.naturalWidth || image.width;
	            _imageDimensions.height = image.naturalHeight || image.height;
	        } else if (typeof VideoFrame !== 'undefined' && image instanceof VideoFrame) {
	            _imageDimensions.width = image.displayWidth;
	            _imageDimensions.height = image.displayHeight;
	        } else {
	            _imageDimensions.width = image.width;
	            _imageDimensions.height = image.height;
	        }
	        return _imageDimensions;
	    }
	    //
	    this.allocateTextureUnit = allocateTextureUnit;
	    this.resetTextureUnits = resetTextureUnits;
	    this.setTexture2D = setTexture2D;
	    this.setTexture2DArray = setTexture2DArray;
	    this.setTexture3D = setTexture3D;
	    this.setTextureCube = setTextureCube;
	    this.rebindTextures = rebindTextures;
	    this.setupRenderTarget = setupRenderTarget;
	    this.updateRenderTargetMipmap = updateRenderTargetMipmap;
	    this.updateMultisampleRenderTarget = updateMultisampleRenderTarget;
	    this.setupDepthRenderbuffer = setupDepthRenderbuffer;
	    this.setupFrameBufferTexture = setupFrameBufferTexture;
	    this.useMultisampledRTT = useMultisampledRTT;
	}
	function WebGLUtils(gl, extensions) {
	    function convert(p, colorSpace = NoColorSpace) {
	        let extension;
	        const transfer = ColorManagement.getTransfer(colorSpace);
	        if (p === UnsignedByteType) return gl.UNSIGNED_BYTE;
	        if (p === UnsignedShort4444Type) return gl.UNSIGNED_SHORT_4_4_4_4;
	        if (p === UnsignedShort5551Type) return gl.UNSIGNED_SHORT_5_5_5_1;
	        if (p === UnsignedInt5999Type) return gl.UNSIGNED_INT_5_9_9_9_REV;
	        if (p === ByteType) return gl.BYTE;
	        if (p === ShortType) return gl.SHORT;
	        if (p === UnsignedShortType) return gl.UNSIGNED_SHORT;
	        if (p === IntType) return gl.INT;
	        if (p === UnsignedIntType) return gl.UNSIGNED_INT;
	        if (p === FloatType) return gl.FLOAT;
	        if (p === HalfFloatType) return gl.HALF_FLOAT;
	        if (p === AlphaFormat) return gl.ALPHA;
	        if (p === RGBFormat) return gl.RGB;
	        if (p === RGBAFormat) return gl.RGBA;
	        if (p === LuminanceFormat) return gl.LUMINANCE;
	        if (p === LuminanceAlphaFormat) return gl.LUMINANCE_ALPHA;
	        if (p === DepthFormat) return gl.DEPTH_COMPONENT;
	        if (p === DepthStencilFormat) return gl.DEPTH_STENCIL;
	        // WebGL2 formats.
	        if (p === RedFormat) return gl.RED;
	        if (p === RedIntegerFormat) return gl.RED_INTEGER;
	        if (p === RGFormat) return gl.RG;
	        if (p === RGIntegerFormat) return gl.RG_INTEGER;
	        if (p === RGBAIntegerFormat) return gl.RGBA_INTEGER;
	        // S3TC
	        if (p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format) {
	            if (transfer === SRGBTransfer) {
	                extension = extensions.get('WEBGL_compressed_texture_s3tc_srgb');
	                if (extension !== null) {
	                    if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_SRGB_S3TC_DXT1_EXT;
	                    if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
	                    if (p === RGBA_S3TC_DXT3_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
	                    if (p === RGBA_S3TC_DXT5_Format) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
	                } else {
	                    return null;
	                }
	            } else {
	                extension = extensions.get('WEBGL_compressed_texture_s3tc');
	                if (extension !== null) {
	                    if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
	                    if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
	                    if (p === RGBA_S3TC_DXT3_Format) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
	                    if (p === RGBA_S3TC_DXT5_Format) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
	                } else {
	                    return null;
	                }
	            }
	        }
	        // PVRTC
	        if (p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format) {
	            extension = extensions.get('WEBGL_compressed_texture_pvrtc');
	            if (extension !== null) {
	                if (p === RGB_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
	                if (p === RGB_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
	                if (p === RGBA_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
	                if (p === RGBA_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
	            } else {
	                return null;
	            }
	        }
	        // ETC
	        if (p === RGB_ETC1_Format || p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format) {
	            extension = extensions.get('WEBGL_compressed_texture_etc');
	            if (extension !== null) {
	                if (p === RGB_ETC1_Format || p === RGB_ETC2_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ETC2 : extension.COMPRESSED_RGB8_ETC2;
	                if (p === RGBA_ETC2_EAC_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : extension.COMPRESSED_RGBA8_ETC2_EAC;
	            } else {
	                return null;
	            }
	        }
	        // ASTC
	        if (p === RGBA_ASTC_4x4_Format || p === RGBA_ASTC_5x4_Format || p === RGBA_ASTC_5x5_Format || p === RGBA_ASTC_6x5_Format || p === RGBA_ASTC_6x6_Format || p === RGBA_ASTC_8x5_Format || p === RGBA_ASTC_8x6_Format || p === RGBA_ASTC_8x8_Format || p === RGBA_ASTC_10x5_Format || p === RGBA_ASTC_10x6_Format || p === RGBA_ASTC_10x8_Format || p === RGBA_ASTC_10x10_Format || p === RGBA_ASTC_12x10_Format || p === RGBA_ASTC_12x12_Format) {
	            extension = extensions.get('WEBGL_compressed_texture_astc');
	            if (extension !== null) {
	                if (p === RGBA_ASTC_4x4_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : extension.COMPRESSED_RGBA_ASTC_4x4_KHR;
	                if (p === RGBA_ASTC_5x4_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : extension.COMPRESSED_RGBA_ASTC_5x4_KHR;
	                if (p === RGBA_ASTC_5x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : extension.COMPRESSED_RGBA_ASTC_5x5_KHR;
	                if (p === RGBA_ASTC_6x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : extension.COMPRESSED_RGBA_ASTC_6x5_KHR;
	                if (p === RGBA_ASTC_6x6_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : extension.COMPRESSED_RGBA_ASTC_6x6_KHR;
	                if (p === RGBA_ASTC_8x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : extension.COMPRESSED_RGBA_ASTC_8x5_KHR;
	                if (p === RGBA_ASTC_8x6_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : extension.COMPRESSED_RGBA_ASTC_8x6_KHR;
	                if (p === RGBA_ASTC_8x8_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : extension.COMPRESSED_RGBA_ASTC_8x8_KHR;
	                if (p === RGBA_ASTC_10x5_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : extension.COMPRESSED_RGBA_ASTC_10x5_KHR;
	                if (p === RGBA_ASTC_10x6_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : extension.COMPRESSED_RGBA_ASTC_10x6_KHR;
	                if (p === RGBA_ASTC_10x8_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : extension.COMPRESSED_RGBA_ASTC_10x8_KHR;
	                if (p === RGBA_ASTC_10x10_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : extension.COMPRESSED_RGBA_ASTC_10x10_KHR;
	                if (p === RGBA_ASTC_12x10_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : extension.COMPRESSED_RGBA_ASTC_12x10_KHR;
	                if (p === RGBA_ASTC_12x12_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : extension.COMPRESSED_RGBA_ASTC_12x12_KHR;
	            } else {
	                return null;
	            }
	        }
	        // BPTC
	        if (p === RGBA_BPTC_Format || p === RGB_BPTC_SIGNED_Format || p === RGB_BPTC_UNSIGNED_Format) {
	            extension = extensions.get('EXT_texture_compression_bptc');
	            if (extension !== null) {
	                if (p === RGBA_BPTC_Format) return transfer === SRGBTransfer ? extension.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT : extension.COMPRESSED_RGBA_BPTC_UNORM_EXT;
	                if (p === RGB_BPTC_SIGNED_Format) return extension.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT;
	                if (p === RGB_BPTC_UNSIGNED_Format) return extension.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT;
	            } else {
	                return null;
	            }
	        }
	        // RGTC
	        if (p === RED_RGTC1_Format || p === SIGNED_RED_RGTC1_Format || p === RED_GREEN_RGTC2_Format || p === SIGNED_RED_GREEN_RGTC2_Format) {
	            extension = extensions.get('EXT_texture_compression_rgtc');
	            if (extension !== null) {
	                if (p === RGBA_BPTC_Format) return extension.COMPRESSED_RED_RGTC1_EXT;
	                if (p === SIGNED_RED_RGTC1_Format) return extension.COMPRESSED_SIGNED_RED_RGTC1_EXT;
	                if (p === RED_GREEN_RGTC2_Format) return extension.COMPRESSED_RED_GREEN_RGTC2_EXT;
	                if (p === SIGNED_RED_GREEN_RGTC2_Format) return extension.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT;
	            } else {
	                return null;
	            }
	        }
	        //
	        if (p === UnsignedInt248Type) return gl.UNSIGNED_INT_24_8;
	        // if "p" can't be resolved, assume the user defines a WebGL constant as a string (fallback/workaround for packed RGB formats)
	        return gl[p] !== undefined ? gl[p] : null;
	    }
	    return {
	        convert: convert
	    };
	}
	const _occlusion_vertex = `
void main() {

	gl_Position = vec4( position, 1.0 );

}`;
	const _occlusion_fragment = `
uniform sampler2DArray depthColor;
uniform float depthWidth;
uniform float depthHeight;

void main() {

	vec2 coord = vec2( gl_FragCoord.x / depthWidth, gl_FragCoord.y / depthHeight );

	if ( coord.x >= 1.0 ) {

		gl_FragDepth = texture( depthColor, vec3( coord.x - 1.0, coord.y, 1 ) ).r;

	} else {

		gl_FragDepth = texture( depthColor, vec3( coord.x, coord.y, 0 ) ).r;

	}

}`;
	class WebXRDepthSensing {
	    init(renderer, depthData, renderState) {
	        if (this.texture === null) {
	            const texture = new Texture$1();
	            const texProps = renderer.properties.get(texture);
	            texProps.__webglTexture = depthData.texture;
	            if (depthData.depthNear !== renderState.depthNear || depthData.depthFar !== renderState.depthFar) {
	                this.depthNear = depthData.depthNear;
	                this.depthFar = depthData.depthFar;
	            }
	            this.texture = texture;
	        }
	    }
	    getMesh(cameraXR) {
	        if (this.texture !== null) {
	            if (this.mesh === null) {
	                const viewport = cameraXR.cameras[0].viewport;
	                const material = new ShaderMaterial({
	                    vertexShader: _occlusion_vertex,
	                    fragmentShader: _occlusion_fragment,
	                    uniforms: {
	                        depthColor: {
	                            value: this.texture
	                        },
	                        depthWidth: {
	                            value: viewport.z
	                        },
	                        depthHeight: {
	                            value: viewport.w
	                        }
	                    }
	                });
	                this.mesh = new Mesh(new PlaneGeometry(20, 20), material);
	            }
	        }
	        return this.mesh;
	    }
	    reset() {
	        this.texture = null;
	        this.mesh = null;
	    }
	    getDepthTexture() {
	        return this.texture;
	    }
	    constructor(){
	        this.texture = null;
	        this.mesh = null;
	        this.depthNear = 0;
	        this.depthFar = 0;
	    }
	}
	class WebXRManager extends EventDispatcher {
	    constructor(renderer, gl){
	        super();
	        const scope = this;
	        let session = null;
	        let framebufferScaleFactor = 1.0;
	        let referenceSpace = null;
	        let referenceSpaceType = 'local-floor';
	        // Set default foveation to maximum.
	        let foveation = 1.0;
	        let customReferenceSpace = null;
	        let pose = null;
	        let glBinding = null;
	        let glProjLayer = null;
	        let glBaseLayer = null;
	        let xrFrame = null;
	        const depthSensing = new WebXRDepthSensing();
	        const attributes = gl.getContextAttributes();
	        let initialRenderTarget = null;
	        let newRenderTarget = null;
	        const controllers = [];
	        const controllerInputSources = [];
	        const currentSize = new Vector2();
	        let currentPixelRatio = null;
	        //
	        const cameraL = new PerspectiveCamera();
	        cameraL.viewport = new Vector4();
	        const cameraR = new PerspectiveCamera();
	        cameraR.viewport = new Vector4();
	        const cameras = [
	            cameraL,
	            cameraR
	        ];
	        const cameraXR = new ArrayCamera();
	        let _currentDepthNear = null;
	        let _currentDepthFar = null;
	        //
	        this.cameraAutoUpdate = true;
	        this.enabled = false;
	        this.isPresenting = false;
	        this.getController = function(index) {
	            let controller = controllers[index];
	            if (controller === undefined) {
	                controller = new WebXRController();
	                controllers[index] = controller;
	            }
	            return controller.getTargetRaySpace();
	        };
	        this.getControllerGrip = function(index) {
	            let controller = controllers[index];
	            if (controller === undefined) {
	                controller = new WebXRController();
	                controllers[index] = controller;
	            }
	            return controller.getGripSpace();
	        };
	        this.getHand = function(index) {
	            let controller = controllers[index];
	            if (controller === undefined) {
	                controller = new WebXRController();
	                controllers[index] = controller;
	            }
	            return controller.getHandSpace();
	        };
	        //
	        function onSessionEvent(event) {
	            const controllerIndex = controllerInputSources.indexOf(event.inputSource);
	            if (controllerIndex === -1) {
	                return;
	            }
	            const controller = controllers[controllerIndex];
	            if (controller !== undefined) {
	                controller.update(event.inputSource, event.frame, customReferenceSpace || referenceSpace);
	                controller.dispatchEvent({
	                    type: event.type,
	                    data: event.inputSource
	                });
	            }
	        }
	        function onSessionEnd() {
	            session.removeEventListener('select', onSessionEvent);
	            session.removeEventListener('selectstart', onSessionEvent);
	            session.removeEventListener('selectend', onSessionEvent);
	            session.removeEventListener('squeeze', onSessionEvent);
	            session.removeEventListener('squeezestart', onSessionEvent);
	            session.removeEventListener('squeezeend', onSessionEvent);
	            session.removeEventListener('end', onSessionEnd);
	            session.removeEventListener('inputsourceschange', onInputSourcesChange);
	            for(let i = 0; i < controllers.length; i++){
	                const inputSource = controllerInputSources[i];
	                if (inputSource === null) continue;
	                controllerInputSources[i] = null;
	                controllers[i].disconnect(inputSource);
	            }
	            _currentDepthNear = null;
	            _currentDepthFar = null;
	            depthSensing.reset();
	            // restore framebuffer/rendering state
	            renderer.setRenderTarget(initialRenderTarget);
	            glBaseLayer = null;
	            glProjLayer = null;
	            glBinding = null;
	            session = null;
	            newRenderTarget = null;
	            //
	            animation.stop();
	            scope.isPresenting = false;
	            renderer.setPixelRatio(currentPixelRatio);
	            renderer.setSize(currentSize.width, currentSize.height, false);
	            scope.dispatchEvent({
	                type: 'sessionend'
	            });
	        }
	        this.setFramebufferScaleFactor = function(value) {
	            framebufferScaleFactor = value;
	            if (scope.isPresenting === true) {
	                console.warn('THREE.WebXRManager: Cannot change framebuffer scale while presenting.');
	            }
	        };
	        this.setReferenceSpaceType = function(value) {
	            referenceSpaceType = value;
	            if (scope.isPresenting === true) {
	                console.warn('THREE.WebXRManager: Cannot change reference space type while presenting.');
	            }
	        };
	        this.getReferenceSpace = function() {
	            return customReferenceSpace || referenceSpace;
	        };
	        this.setReferenceSpace = function(space) {
	            customReferenceSpace = space;
	        };
	        this.getBaseLayer = function() {
	            return glProjLayer !== null ? glProjLayer : glBaseLayer;
	        };
	        this.getBinding = function() {
	            return glBinding;
	        };
	        this.getFrame = function() {
	            return xrFrame;
	        };
	        this.getSession = function() {
	            return session;
	        };
	        this.setSession = async function(value) {
	            session = value;
	            if (session !== null) {
	                initialRenderTarget = renderer.getRenderTarget();
	                session.addEventListener('select', onSessionEvent);
	                session.addEventListener('selectstart', onSessionEvent);
	                session.addEventListener('selectend', onSessionEvent);
	                session.addEventListener('squeeze', onSessionEvent);
	                session.addEventListener('squeezestart', onSessionEvent);
	                session.addEventListener('squeezeend', onSessionEvent);
	                session.addEventListener('end', onSessionEnd);
	                session.addEventListener('inputsourceschange', onInputSourcesChange);
	                if (attributes.xrCompatible !== true) {
	                    await gl.makeXRCompatible();
	                }
	                currentPixelRatio = renderer.getPixelRatio();
	                renderer.getSize(currentSize);
	                // Check that the browser implements the necessary APIs to use an
	                // XRProjectionLayer rather than an XRWebGLLayer
	                const useLayers = typeof XRWebGLBinding !== 'undefined' && 'createProjectionLayer' in XRWebGLBinding.prototype;
	                if (!useLayers) {
	                    const layerInit = {
	                        antialias: attributes.antialias,
	                        alpha: true,
	                        depth: attributes.depth,
	                        stencil: attributes.stencil,
	                        framebufferScaleFactor: framebufferScaleFactor
	                    };
	                    glBaseLayer = new XRWebGLLayer(session, gl, layerInit);
	                    session.updateRenderState({
	                        baseLayer: glBaseLayer
	                    });
	                    renderer.setPixelRatio(1);
	                    renderer.setSize(glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, false);
	                    newRenderTarget = new WebGLRenderTarget(glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, {
	                        format: RGBAFormat,
	                        type: UnsignedByteType,
	                        colorSpace: renderer.outputColorSpace,
	                        stencilBuffer: attributes.stencil,
	                        resolveDepthBuffer: glBaseLayer.ignoreDepthValues === false,
	                        resolveStencilBuffer: glBaseLayer.ignoreDepthValues === false
	                    });
	                } else {
	                    let depthFormat = null;
	                    let depthType = null;
	                    let glDepthFormat = null;
	                    if (attributes.depth) {
	                        glDepthFormat = attributes.stencil ? gl.DEPTH24_STENCIL8 : gl.DEPTH_COMPONENT24;
	                        depthFormat = attributes.stencil ? DepthStencilFormat : DepthFormat;
	                        depthType = attributes.stencil ? UnsignedInt248Type : UnsignedIntType;
	                    }
	                    const projectionlayerInit = {
	                        colorFormat: gl.RGBA8,
	                        depthFormat: glDepthFormat,
	                        scaleFactor: framebufferScaleFactor
	                    };
	                    glBinding = new XRWebGLBinding(session, gl);
	                    glProjLayer = glBinding.createProjectionLayer(projectionlayerInit);
	                    session.updateRenderState({
	                        layers: [
	                            glProjLayer
	                        ]
	                    });
	                    renderer.setPixelRatio(1);
	                    renderer.setSize(glProjLayer.textureWidth, glProjLayer.textureHeight, false);
	                    newRenderTarget = new WebGLRenderTarget(glProjLayer.textureWidth, glProjLayer.textureHeight, {
	                        format: RGBAFormat,
	                        type: UnsignedByteType,
	                        depthTexture: new DepthTexture(glProjLayer.textureWidth, glProjLayer.textureHeight, depthType, undefined, undefined, undefined, undefined, undefined, undefined, depthFormat),
	                        stencilBuffer: attributes.stencil,
	                        colorSpace: renderer.outputColorSpace,
	                        samples: attributes.antialias ? 4 : 0,
	                        resolveDepthBuffer: glProjLayer.ignoreDepthValues === false,
	                        resolveStencilBuffer: glProjLayer.ignoreDepthValues === false
	                    });
	                }
	                newRenderTarget.isXRRenderTarget = true; // TODO Remove this when possible, see #23278
	                this.setFoveation(foveation);
	                customReferenceSpace = null;
	                referenceSpace = await session.requestReferenceSpace(referenceSpaceType);
	                animation.setContext(session);
	                animation.start();
	                scope.isPresenting = true;
	                scope.dispatchEvent({
	                    type: 'sessionstart'
	                });
	            }
	        };
	        this.getEnvironmentBlendMode = function() {
	            if (session !== null) {
	                return session.environmentBlendMode;
	            }
	        };
	        this.getDepthTexture = function() {
	            return depthSensing.getDepthTexture();
	        };
	        function onInputSourcesChange(event) {
	            // Notify disconnected
	            for(let i = 0; i < event.removed.length; i++){
	                const inputSource = event.removed[i];
	                const index = controllerInputSources.indexOf(inputSource);
	                if (index >= 0) {
	                    controllerInputSources[index] = null;
	                    controllers[index].disconnect(inputSource);
	                }
	            }
	            // Notify connected
	            for(let i = 0; i < event.added.length; i++){
	                const inputSource = event.added[i];
	                let controllerIndex = controllerInputSources.indexOf(inputSource);
	                if (controllerIndex === -1) {
	                    // Assign input source a controller that currently has no input source
	                    for(let i = 0; i < controllers.length; i++){
	                        if (i >= controllerInputSources.length) {
	                            controllerInputSources.push(inputSource);
	                            controllerIndex = i;
	                            break;
	                        } else if (controllerInputSources[i] === null) {
	                            controllerInputSources[i] = inputSource;
	                            controllerIndex = i;
	                            break;
	                        }
	                    }
	                    // If all controllers do currently receive input we ignore new ones
	                    if (controllerIndex === -1) break;
	                }
	                const controller = controllers[controllerIndex];
	                if (controller) {
	                    controller.connect(inputSource);
	                }
	            }
	        }
	        //
	        const cameraLPos = new Vector3();
	        const cameraRPos = new Vector3();
	        /**
			 * Assumes 2 cameras that are parallel and share an X-axis, and that
			 * the cameras' projection and world matrices have already been set.
			 * And that near and far planes are identical for both cameras.
			 * Visualization of this technique: https://computergraphics.stackexchange.com/a/4765
			 *
			 * @param {ArrayCamera} camera - The camera to update.
			 * @param {PerspectiveCamera} cameraL - The left camera.
			 * @param {PerspectiveCamera} cameraR - The right camera.
			 */ function setProjectionFromUnion(camera, cameraL, cameraR) {
	            cameraLPos.setFromMatrixPosition(cameraL.matrixWorld);
	            cameraRPos.setFromMatrixPosition(cameraR.matrixWorld);
	            const ipd = cameraLPos.distanceTo(cameraRPos);
	            const projL = cameraL.projectionMatrix.elements;
	            const projR = cameraR.projectionMatrix.elements;
	            // VR systems will have identical far and near planes, and
	            // most likely identical top and bottom frustum extents.
	            // Use the left camera for these values.
	            const near = projL[14] / (projL[10] - 1);
	            const far = projL[14] / (projL[10] + 1);
	            const topFov = (projL[9] + 1) / projL[5];
	            const bottomFov = (projL[9] - 1) / projL[5];
	            const leftFov = (projL[8] - 1) / projL[0];
	            const rightFov = (projR[8] + 1) / projR[0];
	            const left = near * leftFov;
	            const right = near * rightFov;
	            // Calculate the new camera's position offset from the
	            // left camera. xOffset should be roughly half `ipd`.
	            const zOffset = ipd / (-leftFov + rightFov);
	            const xOffset = zOffset * -leftFov;
	            // TODO: Better way to apply this offset?
	            cameraL.matrixWorld.decompose(camera.position, camera.quaternion, camera.scale);
	            camera.translateX(xOffset);
	            camera.translateZ(zOffset);
	            camera.matrixWorld.compose(camera.position, camera.quaternion, camera.scale);
	            camera.matrixWorldInverse.copy(camera.matrixWorld).invert();
	            // Check if the projection uses an infinite far plane.
	            if (projL[10] === -1) {
	                // Use the projection matrix from the left eye.
	                // The camera offset is sufficient to include the view volumes
	                // of both eyes (assuming symmetric projections).
	                camera.projectionMatrix.copy(cameraL.projectionMatrix);
	                camera.projectionMatrixInverse.copy(cameraL.projectionMatrixInverse);
	            } else {
	                // Find the union of the frustum values of the cameras and scale
	                // the values so that the near plane's position does not change in world space,
	                // although must now be relative to the new union camera.
	                const near2 = near + zOffset;
	                const far2 = far + zOffset;
	                const left2 = left - xOffset;
	                const right2 = right + (ipd - xOffset);
	                const top2 = topFov * far / far2 * near2;
	                const bottom2 = bottomFov * far / far2 * near2;
	                camera.projectionMatrix.makePerspective(left2, right2, top2, bottom2, near2, far2);
	                camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert();
	            }
	        }
	        function updateCamera(camera, parent) {
	            if (parent === null) {
	                camera.matrixWorld.copy(camera.matrix);
	            } else {
	                camera.matrixWorld.multiplyMatrices(parent.matrixWorld, camera.matrix);
	            }
	            camera.matrixWorldInverse.copy(camera.matrixWorld).invert();
	        }
	        this.updateCamera = function(camera) {
	            if (session === null) return;
	            let depthNear = camera.near;
	            let depthFar = camera.far;
	            if (depthSensing.texture !== null) {
	                if (depthSensing.depthNear > 0) depthNear = depthSensing.depthNear;
	                if (depthSensing.depthFar > 0) depthFar = depthSensing.depthFar;
	            }
	            cameraXR.near = cameraR.near = cameraL.near = depthNear;
	            cameraXR.far = cameraR.far = cameraL.far = depthFar;
	            if (_currentDepthNear !== cameraXR.near || _currentDepthFar !== cameraXR.far) {
	                // Note that the new renderState won't apply until the next frame. See #18320
	                session.updateRenderState({
	                    depthNear: cameraXR.near,
	                    depthFar: cameraXR.far
	                });
	                _currentDepthNear = cameraXR.near;
	                _currentDepthFar = cameraXR.far;
	            }
	            cameraL.layers.mask = camera.layers.mask | 0b010;
	            cameraR.layers.mask = camera.layers.mask | 0b100;
	            cameraXR.layers.mask = cameraL.layers.mask | cameraR.layers.mask;
	            const parent = camera.parent;
	            const cameras = cameraXR.cameras;
	            updateCamera(cameraXR, parent);
	            for(let i = 0; i < cameras.length; i++){
	                updateCamera(cameras[i], parent);
	            }
	            // update projection matrix for proper view frustum culling
	            if (cameras.length === 2) {
	                setProjectionFromUnion(cameraXR, cameraL, cameraR);
	            } else {
	                // assume single camera setup (AR)
	                cameraXR.projectionMatrix.copy(cameraL.projectionMatrix);
	            }
	            // update user camera and its children
	            updateUserCamera(camera, cameraXR, parent);
	        };
	        function updateUserCamera(camera, cameraXR, parent) {
	            if (parent === null) {
	                camera.matrix.copy(cameraXR.matrixWorld);
	            } else {
	                camera.matrix.copy(parent.matrixWorld);
	                camera.matrix.invert();
	                camera.matrix.multiply(cameraXR.matrixWorld);
	            }
	            camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);
	            camera.updateMatrixWorld(true);
	            camera.projectionMatrix.copy(cameraXR.projectionMatrix);
	            camera.projectionMatrixInverse.copy(cameraXR.projectionMatrixInverse);
	            if (camera.isPerspectiveCamera) {
	                camera.fov = RAD2DEG * 2 * Math.atan(1 / camera.projectionMatrix.elements[5]);
	                camera.zoom = 1;
	            }
	        }
	        this.getCamera = function() {
	            return cameraXR;
	        };
	        this.getFoveation = function() {
	            if (glProjLayer === null && glBaseLayer === null) {
	                return undefined;
	            }
	            return foveation;
	        };
	        this.setFoveation = function(value) {
	            // 0 = no foveation = full resolution
	            // 1 = maximum foveation = the edges render at lower resolution
	            foveation = value;
	            if (glProjLayer !== null) {
	                glProjLayer.fixedFoveation = value;
	            }
	            if (glBaseLayer !== null && glBaseLayer.fixedFoveation !== undefined) {
	                glBaseLayer.fixedFoveation = value;
	            }
	        };
	        this.hasDepthSensing = function() {
	            return depthSensing.texture !== null;
	        };
	        this.getDepthSensingMesh = function() {
	            return depthSensing.getMesh(cameraXR);
	        };
	        // Animation Loop
	        let onAnimationFrameCallback = null;
	        function onAnimationFrame(time, frame) {
	            pose = frame.getViewerPose(customReferenceSpace || referenceSpace);
	            xrFrame = frame;
	            if (pose !== null) {
	                const views = pose.views;
	                if (glBaseLayer !== null) {
	                    renderer.setRenderTargetFramebuffer(newRenderTarget, glBaseLayer.framebuffer);
	                    renderer.setRenderTarget(newRenderTarget);
	                }
	                let cameraXRNeedsUpdate = false;
	                // check if it's necessary to rebuild cameraXR's camera list
	                if (views.length !== cameraXR.cameras.length) {
	                    cameraXR.cameras.length = 0;
	                    cameraXRNeedsUpdate = true;
	                }
	                for(let i = 0; i < views.length; i++){
	                    const view = views[i];
	                    let viewport = null;
	                    if (glBaseLayer !== null) {
	                        viewport = glBaseLayer.getViewport(view);
	                    } else {
	                        const glSubImage = glBinding.getViewSubImage(glProjLayer, view);
	                        viewport = glSubImage.viewport;
	                        // For side-by-side projection, we only produce a single texture for both eyes.
	                        if (i === 0) {
	                            renderer.setRenderTargetTextures(newRenderTarget, glSubImage.colorTexture, glProjLayer.ignoreDepthValues ? undefined : glSubImage.depthStencilTexture);
	                            renderer.setRenderTarget(newRenderTarget);
	                        }
	                    }
	                    let camera = cameras[i];
	                    if (camera === undefined) {
	                        camera = new PerspectiveCamera();
	                        camera.layers.enable(i);
	                        camera.viewport = new Vector4();
	                        cameras[i] = camera;
	                    }
	                    camera.matrix.fromArray(view.transform.matrix);
	                    camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);
	                    camera.projectionMatrix.fromArray(view.projectionMatrix);
	                    camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert();
	                    camera.viewport.set(viewport.x, viewport.y, viewport.width, viewport.height);
	                    if (i === 0) {
	                        cameraXR.matrix.copy(camera.matrix);
	                        cameraXR.matrix.decompose(cameraXR.position, cameraXR.quaternion, cameraXR.scale);
	                    }
	                    if (cameraXRNeedsUpdate === true) {
	                        cameraXR.cameras.push(camera);
	                    }
	                }
	                //
	                const enabledFeatures = session.enabledFeatures;
	                const gpuDepthSensingEnabled = enabledFeatures && enabledFeatures.includes('depth-sensing') && session.depthUsage == 'gpu-optimized';
	                if (gpuDepthSensingEnabled && glBinding) {
	                    const depthData = glBinding.getDepthInformation(views[0]);
	                    if (depthData && depthData.isValid && depthData.texture) {
	                        depthSensing.init(renderer, depthData, session.renderState);
	                    }
	                }
	            }
	            //
	            for(let i = 0; i < controllers.length; i++){
	                const inputSource = controllerInputSources[i];
	                const controller = controllers[i];
	                if (inputSource !== null && controller !== undefined) {
	                    controller.update(inputSource, frame, customReferenceSpace || referenceSpace);
	                }
	            }
	            if (onAnimationFrameCallback) onAnimationFrameCallback(time, frame);
	            if (frame.detectedPlanes) {
	                scope.dispatchEvent({
	                    type: 'planesdetected',
	                    data: frame
	                });
	            }
	            xrFrame = null;
	        }
	        const animation = new WebGLAnimation();
	        animation.setAnimationLoop(onAnimationFrame);
	        this.setAnimationLoop = function(callback) {
	            onAnimationFrameCallback = callback;
	        };
	        this.dispose = function() {};
	    }
	}
	const _e1 = /*@__PURE__*/ new Euler();
	const _m1 = /*@__PURE__*/ new Matrix4();
	function WebGLMaterials(renderer, properties) {
	    function refreshTransformUniform(map, uniform) {
	        if (map.matrixAutoUpdate === true) {
	            map.updateMatrix();
	        }
	        uniform.value.copy(map.matrix);
	    }
	    function refreshFogUniforms(uniforms, fog) {
	        fog.color.getRGB(uniforms.fogColor.value, getUnlitUniformColorSpace(renderer));
	        if (fog.isFog) {
	            uniforms.fogNear.value = fog.near;
	            uniforms.fogFar.value = fog.far;
	        } else if (fog.isFogExp2) {
	            uniforms.fogDensity.value = fog.density;
	        }
	    }
	    function refreshMaterialUniforms(uniforms, material, pixelRatio, height, transmissionRenderTarget) {
	        if (material.isMeshBasicMaterial) {
	            refreshUniformsCommon(uniforms, material);
	        } else if (material.isMeshLambertMaterial) {
	            refreshUniformsCommon(uniforms, material);
	        } else if (material.isMeshToonMaterial) {
	            refreshUniformsCommon(uniforms, material);
	            refreshUniformsToon(uniforms, material);
	        } else if (material.isMeshPhongMaterial) {
	            refreshUniformsCommon(uniforms, material);
	            refreshUniformsPhong(uniforms, material);
	        } else if (material.isMeshStandardMaterial) {
	            refreshUniformsCommon(uniforms, material);
	            refreshUniformsStandard(uniforms, material);
	            if (material.isMeshPhysicalMaterial) {
	                refreshUniformsPhysical(uniforms, material, transmissionRenderTarget);
	            }
	        } else if (material.isMeshMatcapMaterial) {
	            refreshUniformsCommon(uniforms, material);
	            refreshUniformsMatcap(uniforms, material);
	        } else if (material.isMeshDepthMaterial) {
	            refreshUniformsCommon(uniforms, material);
	        } else if (material.isMeshDistanceMaterial) {
	            refreshUniformsCommon(uniforms, material);
	            refreshUniformsDistance(uniforms, material);
	        } else if (material.isMeshNormalMaterial) {
	            refreshUniformsCommon(uniforms, material);
	        } else if (material.isLineBasicMaterial) {
	            refreshUniformsLine(uniforms, material);
	            if (material.isLineDashedMaterial) {
	                refreshUniformsDash(uniforms, material);
	            }
	        } else if (material.isPointsMaterial) {
	            refreshUniformsPoints(uniforms, material, pixelRatio, height);
	        } else if (material.isSpriteMaterial) {
	            refreshUniformsSprites(uniforms, material);
	        } else if (material.isShadowMaterial) {
	            uniforms.color.value.copy(material.color);
	            uniforms.opacity.value = material.opacity;
	        } else if (material.isShaderMaterial) {
	            material.uniformsNeedUpdate = false; // #15581
	        }
	    }
	    function refreshUniformsCommon(uniforms, material) {
	        uniforms.opacity.value = material.opacity;
	        if (material.color) {
	            uniforms.diffuse.value.copy(material.color);
	        }
	        if (material.emissive) {
	            uniforms.emissive.value.copy(material.emissive).multiplyScalar(material.emissiveIntensity);
	        }
	        if (material.map) {
	            uniforms.map.value = material.map;
	            refreshTransformUniform(material.map, uniforms.mapTransform);
	        }
	        if (material.alphaMap) {
	            uniforms.alphaMap.value = material.alphaMap;
	            refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform);
	        }
	        if (material.bumpMap) {
	            uniforms.bumpMap.value = material.bumpMap;
	            refreshTransformUniform(material.bumpMap, uniforms.bumpMapTransform);
	            uniforms.bumpScale.value = material.bumpScale;
	            if (material.side === BackSide) {
	                uniforms.bumpScale.value *= -1;
	            }
	        }
	        if (material.normalMap) {
	            uniforms.normalMap.value = material.normalMap;
	            refreshTransformUniform(material.normalMap, uniforms.normalMapTransform);
	            uniforms.normalScale.value.copy(material.normalScale);
	            if (material.side === BackSide) {
	                uniforms.normalScale.value.negate();
	            }
	        }
	        if (material.displacementMap) {
	            uniforms.displacementMap.value = material.displacementMap;
	            refreshTransformUniform(material.displacementMap, uniforms.displacementMapTransform);
	            uniforms.displacementScale.value = material.displacementScale;
	            uniforms.displacementBias.value = material.displacementBias;
	        }
	        if (material.emissiveMap) {
	            uniforms.emissiveMap.value = material.emissiveMap;
	            refreshTransformUniform(material.emissiveMap, uniforms.emissiveMapTransform);
	        }
	        if (material.specularMap) {
	            uniforms.specularMap.value = material.specularMap;
	            refreshTransformUniform(material.specularMap, uniforms.specularMapTransform);
	        }
	        if (material.alphaTest > 0) {
	            uniforms.alphaTest.value = material.alphaTest;
	        }
	        const materialProperties = properties.get(material);
	        const envMap = materialProperties.envMap;
	        const envMapRotation = materialProperties.envMapRotation;
	        if (envMap) {
	            uniforms.envMap.value = envMap;
	            _e1.copy(envMapRotation);
	            // accommodate left-handed frame
	            _e1.x *= -1;
	            _e1.y *= -1;
	            _e1.z *= -1;
	            if (envMap.isCubeTexture && envMap.isRenderTargetTexture === false) {
	                // environment maps which are not cube render targets or PMREMs follow a different convention
	                _e1.y *= -1;
	                _e1.z *= -1;
	            }
	            uniforms.envMapRotation.value.setFromMatrix4(_m1.makeRotationFromEuler(_e1));
	            uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap.isRenderTargetTexture === false ? -1 : 1;
	            uniforms.reflectivity.value = material.reflectivity;
	            uniforms.ior.value = material.ior;
	            uniforms.refractionRatio.value = material.refractionRatio;
	        }
	        if (material.lightMap) {
	            uniforms.lightMap.value = material.lightMap;
	            uniforms.lightMapIntensity.value = material.lightMapIntensity;
	            refreshTransformUniform(material.lightMap, uniforms.lightMapTransform);
	        }
	        if (material.aoMap) {
	            uniforms.aoMap.value = material.aoMap;
	            uniforms.aoMapIntensity.value = material.aoMapIntensity;
	            refreshTransformUniform(material.aoMap, uniforms.aoMapTransform);
	        }
	    }
	    function refreshUniformsLine(uniforms, material) {
	        uniforms.diffuse.value.copy(material.color);
	        uniforms.opacity.value = material.opacity;
	        if (material.map) {
	            uniforms.map.value = material.map;
	            refreshTransformUniform(material.map, uniforms.mapTransform);
	        }
	    }
	    function refreshUniformsDash(uniforms, material) {
	        uniforms.dashSize.value = material.dashSize;
	        uniforms.totalSize.value = material.dashSize + material.gapSize;
	        uniforms.scale.value = material.scale;
	    }
	    function refreshUniformsPoints(uniforms, material, pixelRatio, height) {
	        uniforms.diffuse.value.copy(material.color);
	        uniforms.opacity.value = material.opacity;
	        uniforms.size.value = material.size * pixelRatio;
	        uniforms.scale.value = height * 0.5;
	        if (material.map) {
	            uniforms.map.value = material.map;
	            refreshTransformUniform(material.map, uniforms.uvTransform);
	        }
	        if (material.alphaMap) {
	            uniforms.alphaMap.value = material.alphaMap;
	            refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform);
	        }
	        if (material.alphaTest > 0) {
	            uniforms.alphaTest.value = material.alphaTest;
	        }
	    }
	    function refreshUniformsSprites(uniforms, material) {
	        uniforms.diffuse.value.copy(material.color);
	        uniforms.opacity.value = material.opacity;
	        uniforms.rotation.value = material.rotation;
	        if (material.map) {
	            uniforms.map.value = material.map;
	            refreshTransformUniform(material.map, uniforms.mapTransform);
	        }
	        if (material.alphaMap) {
	            uniforms.alphaMap.value = material.alphaMap;
	            refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform);
	        }
	        if (material.alphaTest > 0) {
	            uniforms.alphaTest.value = material.alphaTest;
	        }
	    }
	    function refreshUniformsPhong(uniforms, material) {
	        uniforms.specular.value.copy(material.specular);
	        uniforms.shininess.value = Math.max(material.shininess, 1e-4); // to prevent pow( 0.0, 0.0 )
	    }
	    function refreshUniformsToon(uniforms, material) {
	        if (material.gradientMap) {
	            uniforms.gradientMap.value = material.gradientMap;
	        }
	    }
	    function refreshUniformsStandard(uniforms, material) {
	        uniforms.metalness.value = material.metalness;
	        if (material.metalnessMap) {
	            uniforms.metalnessMap.value = material.metalnessMap;
	            refreshTransformUniform(material.metalnessMap, uniforms.metalnessMapTransform);
	        }
	        uniforms.roughness.value = material.roughness;
	        if (material.roughnessMap) {
	            uniforms.roughnessMap.value = material.roughnessMap;
	            refreshTransformUniform(material.roughnessMap, uniforms.roughnessMapTransform);
	        }
	        if (material.envMap) {
	            //uniforms.envMap.value = material.envMap; // part of uniforms common
	            uniforms.envMapIntensity.value = material.envMapIntensity;
	        }
	    }
	    function refreshUniformsPhysical(uniforms, material, transmissionRenderTarget) {
	        uniforms.ior.value = material.ior; // also part of uniforms common
	        if (material.sheen > 0) {
	            uniforms.sheenColor.value.copy(material.sheenColor).multiplyScalar(material.sheen);
	            uniforms.sheenRoughness.value = material.sheenRoughness;
	            if (material.sheenColorMap) {
	                uniforms.sheenColorMap.value = material.sheenColorMap;
	                refreshTransformUniform(material.sheenColorMap, uniforms.sheenColorMapTransform);
	            }
	            if (material.sheenRoughnessMap) {
	                uniforms.sheenRoughnessMap.value = material.sheenRoughnessMap;
	                refreshTransformUniform(material.sheenRoughnessMap, uniforms.sheenRoughnessMapTransform);
	            }
	        }
	        if (material.clearcoat > 0) {
	            uniforms.clearcoat.value = material.clearcoat;
	            uniforms.clearcoatRoughness.value = material.clearcoatRoughness;
	            if (material.clearcoatMap) {
	                uniforms.clearcoatMap.value = material.clearcoatMap;
	                refreshTransformUniform(material.clearcoatMap, uniforms.clearcoatMapTransform);
	            }
	            if (material.clearcoatRoughnessMap) {
	                uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap;
	                refreshTransformUniform(material.clearcoatRoughnessMap, uniforms.clearcoatRoughnessMapTransform);
	            }
	            if (material.clearcoatNormalMap) {
	                uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap;
	                refreshTransformUniform(material.clearcoatNormalMap, uniforms.clearcoatNormalMapTransform);
	                uniforms.clearcoatNormalScale.value.copy(material.clearcoatNormalScale);
	                if (material.side === BackSide) {
	                    uniforms.clearcoatNormalScale.value.negate();
	                }
	            }
	        }
	        if (material.dispersion > 0) {
	            uniforms.dispersion.value = material.dispersion;
	        }
	        if (material.iridescence > 0) {
	            uniforms.iridescence.value = material.iridescence;
	            uniforms.iridescenceIOR.value = material.iridescenceIOR;
	            uniforms.iridescenceThicknessMinimum.value = material.iridescenceThicknessRange[0];
	            uniforms.iridescenceThicknessMaximum.value = material.iridescenceThicknessRange[1];
	            if (material.iridescenceMap) {
	                uniforms.iridescenceMap.value = material.iridescenceMap;
	                refreshTransformUniform(material.iridescenceMap, uniforms.iridescenceMapTransform);
	            }
	            if (material.iridescenceThicknessMap) {
	                uniforms.iridescenceThicknessMap.value = material.iridescenceThicknessMap;
	                refreshTransformUniform(material.iridescenceThicknessMap, uniforms.iridescenceThicknessMapTransform);
	            }
	        }
	        if (material.transmission > 0) {
	            uniforms.transmission.value = material.transmission;
	            uniforms.transmissionSamplerMap.value = transmissionRenderTarget.texture;
	            uniforms.transmissionSamplerSize.value.set(transmissionRenderTarget.width, transmissionRenderTarget.height);
	            if (material.transmissionMap) {
	                uniforms.transmissionMap.value = material.transmissionMap;
	                refreshTransformUniform(material.transmissionMap, uniforms.transmissionMapTransform);
	            }
	            uniforms.thickness.value = material.thickness;
	            if (material.thicknessMap) {
	                uniforms.thicknessMap.value = material.thicknessMap;
	                refreshTransformUniform(material.thicknessMap, uniforms.thicknessMapTransform);
	            }
	            uniforms.attenuationDistance.value = material.attenuationDistance;
	            uniforms.attenuationColor.value.copy(material.attenuationColor);
	        }
	        if (material.anisotropy > 0) {
	            uniforms.anisotropyVector.value.set(material.anisotropy * Math.cos(material.anisotropyRotation), material.anisotropy * Math.sin(material.anisotropyRotation));
	            if (material.anisotropyMap) {
	                uniforms.anisotropyMap.value = material.anisotropyMap;
	                refreshTransformUniform(material.anisotropyMap, uniforms.anisotropyMapTransform);
	            }
	        }
	        uniforms.specularIntensity.value = material.specularIntensity;
	        uniforms.specularColor.value.copy(material.specularColor);
	        if (material.specularColorMap) {
	            uniforms.specularColorMap.value = material.specularColorMap;
	            refreshTransformUniform(material.specularColorMap, uniforms.specularColorMapTransform);
	        }
	        if (material.specularIntensityMap) {
	            uniforms.specularIntensityMap.value = material.specularIntensityMap;
	            refreshTransformUniform(material.specularIntensityMap, uniforms.specularIntensityMapTransform);
	        }
	    }
	    function refreshUniformsMatcap(uniforms, material) {
	        if (material.matcap) {
	            uniforms.matcap.value = material.matcap;
	        }
	    }
	    function refreshUniformsDistance(uniforms, material) {
	        const light = properties.get(material).light;
	        uniforms.referencePosition.value.setFromMatrixPosition(light.matrixWorld);
	        uniforms.nearDistance.value = light.shadow.camera.near;
	        uniforms.farDistance.value = light.shadow.camera.far;
	    }
	    return {
	        refreshFogUniforms: refreshFogUniforms,
	        refreshMaterialUniforms: refreshMaterialUniforms
	    };
	}
	function WebGLUniformsGroups(gl, info, capabilities, state) {
	    let buffers = {};
	    let updateList = {};
	    let allocatedBindingPoints = [];
	    const maxBindingPoints = gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS); // binding points are global whereas block indices are per shader program
	    function bind(uniformsGroup, program) {
	        const webglProgram = program.program;
	        state.uniformBlockBinding(uniformsGroup, webglProgram);
	    }
	    function update(uniformsGroup, program) {
	        let buffer = buffers[uniformsGroup.id];
	        if (buffer === undefined) {
	            prepareUniformsGroup(uniformsGroup);
	            buffer = createBuffer(uniformsGroup);
	            buffers[uniformsGroup.id] = buffer;
	            uniformsGroup.addEventListener('dispose', onUniformsGroupsDispose);
	        }
	        // ensure to update the binding points/block indices mapping for this program
	        const webglProgram = program.program;
	        state.updateUBOMapping(uniformsGroup, webglProgram);
	        // update UBO once per frame
	        const frame = info.render.frame;
	        if (updateList[uniformsGroup.id] !== frame) {
	            updateBufferData(uniformsGroup);
	            updateList[uniformsGroup.id] = frame;
	        }
	    }
	    function createBuffer(uniformsGroup) {
	        // the setup of an UBO is independent of a particular shader program but global
	        const bindingPointIndex = allocateBindingPointIndex();
	        uniformsGroup.__bindingPointIndex = bindingPointIndex;
	        const buffer = gl.createBuffer();
	        const size = uniformsGroup.__size;
	        const usage = uniformsGroup.usage;
	        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
	        gl.bufferData(gl.UNIFORM_BUFFER, size, usage);
	        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
	        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPointIndex, buffer);
	        return buffer;
	    }
	    function allocateBindingPointIndex() {
	        for(let i = 0; i < maxBindingPoints; i++){
	            if (allocatedBindingPoints.indexOf(i) === -1) {
	                allocatedBindingPoints.push(i);
	                return i;
	            }
	        }
	        console.error('THREE.WebGLRenderer: Maximum number of simultaneously usable uniforms groups reached.');
	        return 0;
	    }
	    function updateBufferData(uniformsGroup) {
	        const buffer = buffers[uniformsGroup.id];
	        const uniforms = uniformsGroup.uniforms;
	        const cache = uniformsGroup.__cache;
	        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
	        for(let i = 0, il = uniforms.length; i < il; i++){
	            const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [
	                uniforms[i]
	            ];
	            for(let j = 0, jl = uniformArray.length; j < jl; j++){
	                const uniform = uniformArray[j];
	                if (hasUniformChanged(uniform, i, j, cache) === true) {
	                    const offset = uniform.__offset;
	                    const values = Array.isArray(uniform.value) ? uniform.value : [
	                        uniform.value
	                    ];
	                    let arrayOffset = 0;
	                    for(let k = 0; k < values.length; k++){
	                        const value = values[k];
	                        const info = getUniformSize(value);
	                        // TODO add integer and struct support
	                        if (typeof value === 'number' || typeof value === 'boolean') {
	                            uniform.__data[0] = value;
	                            gl.bufferSubData(gl.UNIFORM_BUFFER, offset + arrayOffset, uniform.__data);
	                        } else if (value.isMatrix3) {
	                            // manually converting 3x3 to 3x4
	                            uniform.__data[0] = value.elements[0];
	                            uniform.__data[1] = value.elements[1];
	                            uniform.__data[2] = value.elements[2];
	                            uniform.__data[3] = 0;
	                            uniform.__data[4] = value.elements[3];
	                            uniform.__data[5] = value.elements[4];
	                            uniform.__data[6] = value.elements[5];
	                            uniform.__data[7] = 0;
	                            uniform.__data[8] = value.elements[6];
	                            uniform.__data[9] = value.elements[7];
	                            uniform.__data[10] = value.elements[8];
	                            uniform.__data[11] = 0;
	                        } else {
	                            value.toArray(uniform.__data, arrayOffset);
	                            arrayOffset += info.storage / Float32Array.BYTES_PER_ELEMENT;
	                        }
	                    }
	                    gl.bufferSubData(gl.UNIFORM_BUFFER, offset, uniform.__data);
	                }
	            }
	        }
	        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
	    }
	    function hasUniformChanged(uniform, index, indexArray, cache) {
	        const value = uniform.value;
	        const indexString = index + '_' + indexArray;
	        if (cache[indexString] === undefined) {
	            // cache entry does not exist so far
	            if (typeof value === 'number' || typeof value === 'boolean') {
	                cache[indexString] = value;
	            } else {
	                cache[indexString] = value.clone();
	            }
	            return true;
	        } else {
	            const cachedObject = cache[indexString];
	            // compare current value with cached entry
	            if (typeof value === 'number' || typeof value === 'boolean') {
	                if (cachedObject !== value) {
	                    cache[indexString] = value;
	                    return true;
	                }
	            } else {
	                if (cachedObject.equals(value) === false) {
	                    cachedObject.copy(value);
	                    return true;
	                }
	            }
	        }
	        return false;
	    }
	    function prepareUniformsGroup(uniformsGroup) {
	        // determine total buffer size according to the STD140 layout
	        // Hint: STD140 is the only supported layout in WebGL 2
	        const uniforms = uniformsGroup.uniforms;
	        let offset = 0; // global buffer offset in bytes
	        const chunkSize = 16; // size of a chunk in bytes
	        for(let i = 0, l = uniforms.length; i < l; i++){
	            const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [
	                uniforms[i]
	            ];
	            for(let j = 0, jl = uniformArray.length; j < jl; j++){
	                const uniform = uniformArray[j];
	                const values = Array.isArray(uniform.value) ? uniform.value : [
	                    uniform.value
	                ];
	                for(let k = 0, kl = values.length; k < kl; k++){
	                    const value = values[k];
	                    const info = getUniformSize(value);
	                    const chunkOffset = offset % chunkSize; // offset in the current chunk
	                    const chunkPadding = chunkOffset % info.boundary; // required padding to match boundary
	                    const chunkStart = chunkOffset + chunkPadding; // the start position in the current chunk for the data
	                    offset += chunkPadding;
	                    // Check for chunk overflow
	                    if (chunkStart !== 0 && chunkSize - chunkStart < info.storage) {
	                        // Add padding and adjust offset
	                        offset += chunkSize - chunkStart;
	                    }
	                    // the following two properties will be used for partial buffer updates
	                    uniform.__data = new Float32Array(info.storage / Float32Array.BYTES_PER_ELEMENT);
	                    uniform.__offset = offset;
	                    // Update the global offset
	                    offset += info.storage;
	                }
	            }
	        }
	        // ensure correct final padding
	        const chunkOffset = offset % chunkSize;
	        if (chunkOffset > 0) offset += chunkSize - chunkOffset;
	        //
	        uniformsGroup.__size = offset;
	        uniformsGroup.__cache = {};
	        return this;
	    }
	    function getUniformSize(value) {
	        const info = {
	            boundary: 0,
	            storage: 0 // bytes
	        };
	        // determine sizes according to STD140
	        if (typeof value === 'number' || typeof value === 'boolean') {
	            // float/int/bool
	            info.boundary = 4;
	            info.storage = 4;
	        } else if (value.isVector2) {
	            // vec2
	            info.boundary = 8;
	            info.storage = 8;
	        } else if (value.isVector3 || value.isColor) {
	            // vec3
	            info.boundary = 16;
	            info.storage = 12; // evil: vec3 must start on a 16-byte boundary but it only consumes 12 bytes
	        } else if (value.isVector4) {
	            // vec4
	            info.boundary = 16;
	            info.storage = 16;
	        } else if (value.isMatrix3) {
	            // mat3 (in STD140 a 3x3 matrix is represented as 3x4)
	            info.boundary = 48;
	            info.storage = 48;
	        } else if (value.isMatrix4) {
	            // mat4
	            info.boundary = 64;
	            info.storage = 64;
	        } else if (value.isTexture) {
	            console.warn('THREE.WebGLRenderer: Texture samplers can not be part of an uniforms group.');
	        } else {
	            console.warn('THREE.WebGLRenderer: Unsupported uniform value type.', value);
	        }
	        return info;
	    }
	    function onUniformsGroupsDispose(event) {
	        const uniformsGroup = event.target;
	        uniformsGroup.removeEventListener('dispose', onUniformsGroupsDispose);
	        const index = allocatedBindingPoints.indexOf(uniformsGroup.__bindingPointIndex);
	        allocatedBindingPoints.splice(index, 1);
	        gl.deleteBuffer(buffers[uniformsGroup.id]);
	        delete buffers[uniformsGroup.id];
	        delete updateList[uniformsGroup.id];
	    }
	    function dispose() {
	        for(const id in buffers){
	            gl.deleteBuffer(buffers[id]);
	        }
	        allocatedBindingPoints = [];
	        buffers = {};
	        updateList = {};
	    }
	    return {
	        bind: bind,
	        update: update,
	        dispose: dispose
	    };
	}
	class WebGLRenderer {
	    get coordinateSystem() {
	        return WebGLCoordinateSystem;
	    }
	    get outputColorSpace() {
	        return this._outputColorSpace;
	    }
	    set outputColorSpace(colorSpace) {
	        this._outputColorSpace = colorSpace;
	        const gl = this.getContext();
	        gl.drawingBufferColorspace = ColorManagement._getDrawingBufferColorSpace(colorSpace);
	        gl.unpackColorSpace = ColorManagement._getUnpackColorSpace();
	    }
	    constructor(parameters = {}){
	        const { canvas = createCanvasElement(), context = null, depth = true, stencil = false, alpha = false, antialias = false, premultipliedAlpha = true, preserveDrawingBuffer = false, powerPreference = 'default', failIfMajorPerformanceCaveat = false, reverseDepthBuffer = false } = parameters;
	        this.isWebGLRenderer = true;
	        let _alpha;
	        if (context !== null) {
	            if (typeof WebGLRenderingContext !== 'undefined' && context instanceof WebGLRenderingContext) {
	                throw new Error('THREE.WebGLRenderer: WebGL 1 is not supported since r163.');
	            }
	            _alpha = context.getContextAttributes().alpha;
	        } else {
	            _alpha = alpha;
	        }
	        const uintClearColor = new Uint32Array(4);
	        const intClearColor = new Int32Array(4);
	        let currentRenderList = null;
	        let currentRenderState = null;
	        // render() can be called from within a callback triggered by another render.
	        // We track this so that the nested render call gets its list and state isolated from the parent render call.
	        const renderListStack = [];
	        const renderStateStack = [];
	        // public properties
	        this.domElement = canvas;
	        // Debug configuration container
	        this.debug = {
	            /**
				 * Enables error checking and reporting when shader programs are being compiled
				 * @type {boolean}
				 */ checkShaderErrors: true,
	            /**
				 * Callback for custom error reporting.
				 * @type {?Function}
				 */ onShaderError: null
	        };
	        // clearing
	        this.autoClear = true;
	        this.autoClearColor = true;
	        this.autoClearDepth = true;
	        this.autoClearStencil = true;
	        // scene graph
	        this.sortObjects = true;
	        // user-defined clipping
	        this.clippingPlanes = [];
	        this.localClippingEnabled = false;
	        // physically based shading
	        this._outputColorSpace = SRGBColorSpace;
	        // tone mapping
	        this.toneMapping = NoToneMapping;
	        this.toneMappingExposure = 1.0;
	        // internal properties
	        const _this = this;
	        let _isContextLost = false;
	        // internal state cache
	        let _currentActiveCubeFace = 0;
	        let _currentActiveMipmapLevel = 0;
	        let _currentRenderTarget = null;
	        let _currentMaterialId = -1;
	        let _currentCamera = null;
	        const _currentViewport = new Vector4();
	        const _currentScissor = new Vector4();
	        let _currentScissorTest = null;
	        const _currentClearColor = new Color(0x000000);
	        let _currentClearAlpha = 0;
	        //
	        let _width = canvas.width;
	        let _height = canvas.height;
	        let _pixelRatio = 1;
	        let _opaqueSort = null;
	        let _transparentSort = null;
	        const _viewport = new Vector4(0, 0, _width, _height);
	        const _scissor = new Vector4(0, 0, _width, _height);
	        let _scissorTest = false;
	        // frustum
	        const _frustum = new Frustum();
	        // clipping
	        let _clippingEnabled = false;
	        let _localClippingEnabled = false;
	        // transmission render target scale
	        this.transmissionResolutionScale = 1.0;
	        // camera matrices cache
	        const _currentProjectionMatrix = new Matrix4();
	        const _projScreenMatrix = new Matrix4();
	        const _vector3 = new Vector3();
	        const _vector4 = new Vector4();
	        const _emptyScene = {
	            background: null,
	            fog: null,
	            environment: null,
	            overrideMaterial: null,
	            isScene: true
	        };
	        let _renderBackground = false;
	        function getTargetPixelRatio() {
	            return _currentRenderTarget === null ? _pixelRatio : 1;
	        }
	        // initialize
	        let _gl = context;
	        function getContext(contextName, contextAttributes) {
	            return canvas.getContext(contextName, contextAttributes);
	        }
	        try {
	            const contextAttributes = {
	                alpha: true,
	                depth,
	                stencil,
	                antialias,
	                premultipliedAlpha,
	                preserveDrawingBuffer,
	                powerPreference,
	                failIfMajorPerformanceCaveat
	            };
	            // OffscreenCanvas does not have setAttribute, see #22811
	            if ('setAttribute' in canvas) canvas.setAttribute('data-engine', `three.js r${REVISION}`);
	            // event listeners must be registered before WebGL context is created, see #12753
	            canvas.addEventListener('webglcontextlost', onContextLost, false);
	            canvas.addEventListener('webglcontextrestored', onContextRestore, false);
	            canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
	            if (_gl === null) {
	                const contextName = 'webgl2';
	                _gl = getContext(contextName, contextAttributes);
	                if (_gl === null) {
	                    if (getContext(contextName)) {
	                        throw new Error('Error creating WebGL context with your selected attributes.');
	                    } else {
	                        throw new Error('Error creating WebGL context.');
	                    }
	                }
	            }
	        } catch (error) {
	            console.error('THREE.WebGLRenderer: ' + error.message);
	            throw error;
	        }
	        let extensions, capabilities, state, info;
	        let properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects;
	        let programCache, materials, renderLists, renderStates, clipping, shadowMap;
	        let background, morphtargets, bufferRenderer, indexedBufferRenderer;
	        let utils, bindingStates, uniformsGroups;
	        function initGLContext() {
	            extensions = new WebGLExtensions(_gl);
	            extensions.init();
	            utils = new WebGLUtils(_gl, extensions);
	            capabilities = new WebGLCapabilities(_gl, extensions, parameters, utils);
	            state = new WebGLState(_gl, extensions);
	            if (capabilities.reverseDepthBuffer && reverseDepthBuffer) {
	                state.buffers.depth.setReversed(true);
	            }
	            info = new WebGLInfo(_gl);
	            properties = new WebGLProperties();
	            textures = new WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info);
	            cubemaps = new WebGLCubeMaps(_this);
	            cubeuvmaps = new WebGLCubeUVMaps(_this);
	            attributes = new WebGLAttributes(_gl);
	            bindingStates = new WebGLBindingStates(_gl, attributes);
	            geometries = new WebGLGeometries(_gl, attributes, info, bindingStates);
	            objects = new WebGLObjects(_gl, geometries, attributes, info);
	            morphtargets = new WebGLMorphtargets(_gl, capabilities, textures);
	            clipping = new WebGLClipping(properties);
	            programCache = new WebGLPrograms(_this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping);
	            materials = new WebGLMaterials(_this, properties);
	            renderLists = new WebGLRenderLists();
	            renderStates = new WebGLRenderStates(extensions);
	            background = new WebGLBackground(_this, cubemaps, cubeuvmaps, state, objects, _alpha, premultipliedAlpha);
	            shadowMap = new WebGLShadowMap(_this, objects, capabilities);
	            uniformsGroups = new WebGLUniformsGroups(_gl, info, capabilities, state);
	            bufferRenderer = new WebGLBufferRenderer(_gl, extensions, info);
	            indexedBufferRenderer = new WebGLIndexedBufferRenderer(_gl, extensions, info);
	            info.programs = programCache.programs;
	            _this.capabilities = capabilities;
	            _this.extensions = extensions;
	            _this.properties = properties;
	            _this.renderLists = renderLists;
	            _this.shadowMap = shadowMap;
	            _this.state = state;
	            _this.info = info;
	        }
	        initGLContext();
	        // xr
	        const xr = new WebXRManager(_this, _gl);
	        this.xr = xr;
	        // API
	        this.getContext = function() {
	            return _gl;
	        };
	        this.getContextAttributes = function() {
	            return _gl.getContextAttributes();
	        };
	        this.forceContextLoss = function() {
	            const extension = extensions.get('WEBGL_lose_context');
	            if (extension) extension.loseContext();
	        };
	        this.forceContextRestore = function() {
	            const extension = extensions.get('WEBGL_lose_context');
	            if (extension) extension.restoreContext();
	        };
	        this.getPixelRatio = function() {
	            return _pixelRatio;
	        };
	        this.setPixelRatio = function(value) {
	            if (value === undefined) return;
	            _pixelRatio = value;
	            this.setSize(_width, _height, false);
	        };
	        this.getSize = function(target) {
	            return target.set(_width, _height);
	        };
	        this.setSize = function(width, height, updateStyle = true) {
	            if (xr.isPresenting) {
	                console.warn('THREE.WebGLRenderer: Can\'t change size while VR device is presenting.');
	                return;
	            }
	            _width = width;
	            _height = height;
	            canvas.width = Math.floor(width * _pixelRatio);
	            canvas.height = Math.floor(height * _pixelRatio);
	            if (updateStyle === true) {
	                canvas.style.width = width + 'px';
	                canvas.style.height = height + 'px';
	            }
	            this.setViewport(0, 0, width, height);
	        };
	        this.getDrawingBufferSize = function(target) {
	            return target.set(_width * _pixelRatio, _height * _pixelRatio).floor();
	        };
	        this.setDrawingBufferSize = function(width, height, pixelRatio) {
	            _width = width;
	            _height = height;
	            _pixelRatio = pixelRatio;
	            canvas.width = Math.floor(width * pixelRatio);
	            canvas.height = Math.floor(height * pixelRatio);
	            this.setViewport(0, 0, width, height);
	        };
	        this.getCurrentViewport = function(target) {
	            return target.copy(_currentViewport);
	        };
	        this.getViewport = function(target) {
	            return target.copy(_viewport);
	        };
	        this.setViewport = function(x, y, width, height) {
	            if (x.isVector4) {
	                _viewport.set(x.x, x.y, x.z, x.w);
	            } else {
	                _viewport.set(x, y, width, height);
	            }
	            state.viewport(_currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).round());
	        };
	        this.getScissor = function(target) {
	            return target.copy(_scissor);
	        };
	        this.setScissor = function(x, y, width, height) {
	            if (x.isVector4) {
	                _scissor.set(x.x, x.y, x.z, x.w);
	            } else {
	                _scissor.set(x, y, width, height);
	            }
	            state.scissor(_currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).round());
	        };
	        this.getScissorTest = function() {
	            return _scissorTest;
	        };
	        this.setScissorTest = function(boolean) {
	            state.setScissorTest(_scissorTest = boolean);
	        };
	        this.setOpaqueSort = function(method) {
	            _opaqueSort = method;
	        };
	        this.setTransparentSort = function(method) {
	            _transparentSort = method;
	        };
	        // Clearing
	        this.getClearColor = function(target) {
	            return target.copy(background.getClearColor());
	        };
	        this.setClearColor = function() {
	            background.setClearColor(...arguments);
	        };
	        this.getClearAlpha = function() {
	            return background.getClearAlpha();
	        };
	        this.setClearAlpha = function() {
	            background.setClearAlpha(...arguments);
	        };
	        this.clear = function(color = true, depth = true, stencil = true) {
	            let bits = 0;
	            if (color) {
	                // check if we're trying to clear an integer target
	                let isIntegerFormat = false;
	                if (_currentRenderTarget !== null) {
	                    const targetFormat = _currentRenderTarget.texture.format;
	                    isIntegerFormat = targetFormat === RGBAIntegerFormat || targetFormat === RGIntegerFormat || targetFormat === RedIntegerFormat;
	                }
	                // use the appropriate clear functions to clear the target if it's a signed
	                // or unsigned integer target
	                if (isIntegerFormat) {
	                    const targetType = _currentRenderTarget.texture.type;
	                    const isUnsignedType = targetType === UnsignedByteType || targetType === UnsignedIntType || targetType === UnsignedShortType || targetType === UnsignedInt248Type || targetType === UnsignedShort4444Type || targetType === UnsignedShort5551Type;
	                    const clearColor = background.getClearColor();
	                    const a = background.getClearAlpha();
	                    const r = clearColor.r;
	                    const g = clearColor.g;
	                    const b = clearColor.b;
	                    if (isUnsignedType) {
	                        uintClearColor[0] = r;
	                        uintClearColor[1] = g;
	                        uintClearColor[2] = b;
	                        uintClearColor[3] = a;
	                        _gl.clearBufferuiv(_gl.COLOR, 0, uintClearColor);
	                    } else {
	                        intClearColor[0] = r;
	                        intClearColor[1] = g;
	                        intClearColor[2] = b;
	                        intClearColor[3] = a;
	                        _gl.clearBufferiv(_gl.COLOR, 0, intClearColor);
	                    }
	                } else {
	                    bits |= _gl.COLOR_BUFFER_BIT;
	                }
	            }
	            if (depth) {
	                bits |= _gl.DEPTH_BUFFER_BIT;
	            }
	            if (stencil) {
	                bits |= _gl.STENCIL_BUFFER_BIT;
	                this.state.buffers.stencil.setMask(0xffffffff);
	            }
	            _gl.clear(bits);
	        };
	        this.clearColor = function() {
	            this.clear(true, false, false);
	        };
	        this.clearDepth = function() {
	            this.clear(false, true, false);
	        };
	        this.clearStencil = function() {
	            this.clear(false, false, true);
	        };
	        //
	        this.dispose = function() {
	            canvas.removeEventListener('webglcontextlost', onContextLost, false);
	            canvas.removeEventListener('webglcontextrestored', onContextRestore, false);
	            canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
	            background.dispose();
	            renderLists.dispose();
	            renderStates.dispose();
	            properties.dispose();
	            cubemaps.dispose();
	            cubeuvmaps.dispose();
	            objects.dispose();
	            bindingStates.dispose();
	            uniformsGroups.dispose();
	            programCache.dispose();
	            xr.dispose();
	            xr.removeEventListener('sessionstart', onXRSessionStart);
	            xr.removeEventListener('sessionend', onXRSessionEnd);
	            animation.stop();
	        };
	        // Events
	        function onContextLost(event) {
	            event.preventDefault();
	            console.log('THREE.WebGLRenderer: Context Lost.');
	            _isContextLost = true;
	        }
	        function onContextRestore() {
	            console.log('THREE.WebGLRenderer: Context Restored.');
	            _isContextLost = false;
	            const infoAutoReset = info.autoReset;
	            const shadowMapEnabled = shadowMap.enabled;
	            const shadowMapAutoUpdate = shadowMap.autoUpdate;
	            const shadowMapNeedsUpdate = shadowMap.needsUpdate;
	            const shadowMapType = shadowMap.type;
	            initGLContext();
	            info.autoReset = infoAutoReset;
	            shadowMap.enabled = shadowMapEnabled;
	            shadowMap.autoUpdate = shadowMapAutoUpdate;
	            shadowMap.needsUpdate = shadowMapNeedsUpdate;
	            shadowMap.type = shadowMapType;
	        }
	        function onContextCreationError(event) {
	            console.error('THREE.WebGLRenderer: A WebGL context could not be created. Reason: ', event.statusMessage);
	        }
	        function onMaterialDispose(event) {
	            const material = event.target;
	            material.removeEventListener('dispose', onMaterialDispose);
	            deallocateMaterial(material);
	        }
	        // Buffer deallocation
	        function deallocateMaterial(material) {
	            releaseMaterialProgramReferences(material);
	            properties.remove(material);
	        }
	        function releaseMaterialProgramReferences(material) {
	            const programs = properties.get(material).programs;
	            if (programs !== undefined) {
	                programs.forEach(function(program) {
	                    programCache.releaseProgram(program);
	                });
	                if (material.isShaderMaterial) {
	                    programCache.releaseShaderCache(material);
	                }
	            }
	        }
	        // Buffer rendering
	        this.renderBufferDirect = function(camera, scene, geometry, material, object, group) {
	            if (scene === null) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)
	            const frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0;
	            const program = setProgram(camera, scene, geometry, material, object);
	            state.setMaterial(material, frontFaceCW);
	            //
	            let index = geometry.index;
	            let rangeFactor = 1;
	            if (material.wireframe === true) {
	                index = geometries.getWireframeAttribute(geometry);
	                if (index === undefined) return;
	                rangeFactor = 2;
	            }
	            //
	            const drawRange = geometry.drawRange;
	            const position = geometry.attributes.position;
	            let drawStart = drawRange.start * rangeFactor;
	            let drawEnd = (drawRange.start + drawRange.count) * rangeFactor;
	            if (group !== null) {
	                drawStart = Math.max(drawStart, group.start * rangeFactor);
	                drawEnd = Math.min(drawEnd, (group.start + group.count) * rangeFactor);
	            }
	            if (index !== null) {
	                drawStart = Math.max(drawStart, 0);
	                drawEnd = Math.min(drawEnd, index.count);
	            } else if (position !== undefined && position !== null) {
	                drawStart = Math.max(drawStart, 0);
	                drawEnd = Math.min(drawEnd, position.count);
	            }
	            const drawCount = drawEnd - drawStart;
	            if (drawCount < 0 || drawCount === Infinity) return;
	            //
	            bindingStates.setup(object, material, program, geometry, index);
	            let attribute;
	            let renderer = bufferRenderer;
	            if (index !== null) {
	                attribute = attributes.get(index);
	                renderer = indexedBufferRenderer;
	                renderer.setIndex(attribute);
	            }
	            //
	            if (object.isMesh) {
	                if (material.wireframe === true) {
	                    state.setLineWidth(material.wireframeLinewidth * getTargetPixelRatio());
	                    renderer.setMode(_gl.LINES);
	                } else {
	                    renderer.setMode(_gl.TRIANGLES);
	                }
	            } else if (object.isLine) {
	                let lineWidth = material.linewidth;
	                if (lineWidth === undefined) lineWidth = 1; // Not using Line*Material
	                state.setLineWidth(lineWidth * getTargetPixelRatio());
	                if (object.isLineSegments) {
	                    renderer.setMode(_gl.LINES);
	                } else if (object.isLineLoop) {
	                    renderer.setMode(_gl.LINE_LOOP);
	                } else {
	                    renderer.setMode(_gl.LINE_STRIP);
	                }
	            } else if (object.isPoints) {
	                renderer.setMode(_gl.POINTS);
	            } else if (object.isSprite) {
	                renderer.setMode(_gl.TRIANGLES);
	            }
	            if (object.isBatchedMesh) {
	                if (object._multiDrawInstances !== null) {
	                    // @deprecated, r174
	                    warnOnce('THREE.WebGLRenderer: renderMultiDrawInstances has been deprecated and will be removed in r184. Append to renderMultiDraw arguments and use indirection.');
	                    renderer.renderMultiDrawInstances(object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount, object._multiDrawInstances);
	                } else {
	                    if (!extensions.get('WEBGL_multi_draw')) {
	                        const starts = object._multiDrawStarts;
	                        const counts = object._multiDrawCounts;
	                        const drawCount = object._multiDrawCount;
	                        const bytesPerElement = index ? attributes.get(index).bytesPerElement : 1;
	                        const uniforms = properties.get(material).currentProgram.getUniforms();
	                        for(let i = 0; i < drawCount; i++){
	                            uniforms.setValue(_gl, '_gl_DrawID', i);
	                            renderer.render(starts[i] / bytesPerElement, counts[i]);
	                        }
	                    } else {
	                        renderer.renderMultiDraw(object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount);
	                    }
	                }
	            } else if (object.isInstancedMesh) {
	                renderer.renderInstances(drawStart, drawCount, object.count);
	            } else if (geometry.isInstancedBufferGeometry) {
	                const maxInstanceCount = geometry._maxInstanceCount !== undefined ? geometry._maxInstanceCount : Infinity;
	                const instanceCount = Math.min(geometry.instanceCount, maxInstanceCount);
	                renderer.renderInstances(drawStart, drawCount, instanceCount);
	            } else {
	                renderer.render(drawStart, drawCount);
	            }
	        };
	        // Compile
	        function prepareMaterial(material, scene, object) {
	            if (material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false) {
	                material.side = BackSide;
	                material.needsUpdate = true;
	                getProgram(material, scene, object);
	                material.side = FrontSide;
	                material.needsUpdate = true;
	                getProgram(material, scene, object);
	                material.side = DoubleSide;
	            } else {
	                getProgram(material, scene, object);
	            }
	        }
	        this.compile = function(scene, camera, targetScene = null) {
	            if (targetScene === null) targetScene = scene;
	            currentRenderState = renderStates.get(targetScene);
	            currentRenderState.init(camera);
	            renderStateStack.push(currentRenderState);
	            // gather lights from both the target scene and the new object that will be added to the scene.
	            targetScene.traverseVisible(function(object) {
	                if (object.isLight && object.layers.test(camera.layers)) {
	                    currentRenderState.pushLight(object);
	                    if (object.castShadow) {
	                        currentRenderState.pushShadow(object);
	                    }
	                }
	            });
	            if (scene !== targetScene) {
	                scene.traverseVisible(function(object) {
	                    if (object.isLight && object.layers.test(camera.layers)) {
	                        currentRenderState.pushLight(object);
	                        if (object.castShadow) {
	                            currentRenderState.pushShadow(object);
	                        }
	                    }
	                });
	            }
	            currentRenderState.setupLights();
	            // Only initialize materials in the new scene, not the targetScene.
	            const materials = new Set();
	            scene.traverse(function(object) {
	                if (!(object.isMesh || object.isPoints || object.isLine || object.isSprite)) {
	                    return;
	                }
	                const material = object.material;
	                if (material) {
	                    if (Array.isArray(material)) {
	                        for(let i = 0; i < material.length; i++){
	                            const material2 = material[i];
	                            prepareMaterial(material2, targetScene, object);
	                            materials.add(material2);
	                        }
	                    } else {
	                        prepareMaterial(material, targetScene, object);
	                        materials.add(material);
	                    }
	                }
	            });
	            currentRenderState = renderStateStack.pop();
	            return materials;
	        };
	        // compileAsync
	        this.compileAsync = function(scene, camera, targetScene = null) {
	            const materials = this.compile(scene, camera, targetScene);
	            // Wait for all the materials in the new object to indicate that they're
	            // ready to be used before resolving the promise.
	            return new Promise((resolve)=>{
	                function checkMaterialsReady() {
	                    materials.forEach(function(material) {
	                        const materialProperties = properties.get(material);
	                        const program = materialProperties.currentProgram;
	                        if (program.isReady()) {
	                            // remove any programs that report they're ready to use from the list
	                            materials.delete(material);
	                        }
	                    });
	                    // once the list of compiling materials is empty, call the callback
	                    if (materials.size === 0) {
	                        resolve(scene);
	                        return;
	                    }
	                    // if some materials are still not ready, wait a bit and check again
	                    setTimeout(checkMaterialsReady, 10);
	                }
	                if (extensions.get('KHR_parallel_shader_compile') !== null) {
	                    // If we can check the compilation status of the materials without
	                    // blocking then do so right away.
	                    checkMaterialsReady();
	                } else {
	                    // Otherwise start by waiting a bit to give the materials we just
	                    // initialized a chance to finish.
	                    setTimeout(checkMaterialsReady, 10);
	                }
	            });
	        };
	        // Animation Loop
	        let onAnimationFrameCallback = null;
	        function onAnimationFrame(time) {
	            if (onAnimationFrameCallback) onAnimationFrameCallback(time);
	        }
	        function onXRSessionStart() {
	            animation.stop();
	        }
	        function onXRSessionEnd() {
	            animation.start();
	        }
	        const animation = new WebGLAnimation();
	        animation.setAnimationLoop(onAnimationFrame);
	        if (typeof self !== 'undefined') animation.setContext(self);
	        this.setAnimationLoop = function(callback) {
	            onAnimationFrameCallback = callback;
	            xr.setAnimationLoop(callback);
	            callback === null ? animation.stop() : animation.start();
	        };
	        xr.addEventListener('sessionstart', onXRSessionStart);
	        xr.addEventListener('sessionend', onXRSessionEnd);
	        // Rendering
	        this.render = function(scene, camera) {
	            if (camera !== undefined && camera.isCamera !== true) {
	                console.error('THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.');
	                return;
	            }
	            if (_isContextLost === true) return;
	            // update scene graph
	            if (scene.matrixWorldAutoUpdate === true) scene.updateMatrixWorld();
	            // update camera matrices and frustum
	            if (camera.parent === null && camera.matrixWorldAutoUpdate === true) camera.updateMatrixWorld();
	            if (xr.enabled === true && xr.isPresenting === true) {
	                if (xr.cameraAutoUpdate === true) xr.updateCamera(camera);
	                camera = xr.getCamera(); // use XR camera for rendering
	            }
	            //
	            if (scene.isScene === true) scene.onBeforeRender(_this, scene, camera, _currentRenderTarget);
	            currentRenderState = renderStates.get(scene, renderStateStack.length);
	            currentRenderState.init(camera);
	            renderStateStack.push(currentRenderState);
	            _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
	            _frustum.setFromProjectionMatrix(_projScreenMatrix);
	            _localClippingEnabled = this.localClippingEnabled;
	            _clippingEnabled = clipping.init(this.clippingPlanes, _localClippingEnabled);
	            currentRenderList = renderLists.get(scene, renderListStack.length);
	            currentRenderList.init();
	            renderListStack.push(currentRenderList);
	            if (xr.enabled === true && xr.isPresenting === true) {
	                const depthSensingMesh = _this.xr.getDepthSensingMesh();
	                if (depthSensingMesh !== null) {
	                    projectObject(depthSensingMesh, camera, -Infinity, _this.sortObjects);
	                }
	            }
	            projectObject(scene, camera, 0, _this.sortObjects);
	            currentRenderList.finish();
	            if (_this.sortObjects === true) {
	                currentRenderList.sort(_opaqueSort, _transparentSort);
	            }
	            _renderBackground = xr.enabled === false || xr.isPresenting === false || xr.hasDepthSensing() === false;
	            if (_renderBackground) {
	                background.addToRenderList(currentRenderList, scene);
	            }
	            //
	            this.info.render.frame++;
	            if (_clippingEnabled === true) clipping.beginShadows();
	            const shadowsArray = currentRenderState.state.shadowsArray;
	            shadowMap.render(shadowsArray, scene, camera);
	            if (_clippingEnabled === true) clipping.endShadows();
	            //
	            if (this.info.autoReset === true) this.info.reset();
	            // render scene
	            const opaqueObjects = currentRenderList.opaque;
	            const transmissiveObjects = currentRenderList.transmissive;
	            currentRenderState.setupLights();
	            if (camera.isArrayCamera) {
	                const cameras = camera.cameras;
	                if (transmissiveObjects.length > 0) {
	                    for(let i = 0, l = cameras.length; i < l; i++){
	                        const camera2 = cameras[i];
	                        renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera2);
	                    }
	                }
	                if (_renderBackground) background.render(scene);
	                for(let i = 0, l = cameras.length; i < l; i++){
	                    const camera2 = cameras[i];
	                    renderScene(currentRenderList, scene, camera2, camera2.viewport);
	                }
	            } else {
	                if (transmissiveObjects.length > 0) renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera);
	                if (_renderBackground) background.render(scene);
	                renderScene(currentRenderList, scene, camera);
	            }
	            //
	            if (_currentRenderTarget !== null && _currentActiveMipmapLevel === 0) {
	                // resolve multisample renderbuffers to a single-sample texture if necessary
	                textures.updateMultisampleRenderTarget(_currentRenderTarget);
	                // Generate mipmap if we're using any kind of mipmap filtering
	                textures.updateRenderTargetMipmap(_currentRenderTarget);
	            }
	            //
	            if (scene.isScene === true) scene.onAfterRender(_this, scene, camera);
	            // _gl.finish();
	            bindingStates.resetDefaultState();
	            _currentMaterialId = -1;
	            _currentCamera = null;
	            renderStateStack.pop();
	            if (renderStateStack.length > 0) {
	                currentRenderState = renderStateStack[renderStateStack.length - 1];
	                if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, currentRenderState.state.camera);
	            } else {
	                currentRenderState = null;
	            }
	            renderListStack.pop();
	            if (renderListStack.length > 0) {
	                currentRenderList = renderListStack[renderListStack.length - 1];
	            } else {
	                currentRenderList = null;
	            }
	        };
	        function projectObject(object, camera, groupOrder, sortObjects) {
	            if (object.visible === false) return;
	            const visible = object.layers.test(camera.layers);
	            if (visible) {
	                if (object.isGroup) {
	                    groupOrder = object.renderOrder;
	                } else if (object.isLOD) {
	                    if (object.autoUpdate === true) object.update(camera);
	                } else if (object.isLight) {
	                    currentRenderState.pushLight(object);
	                    if (object.castShadow) {
	                        currentRenderState.pushShadow(object);
	                    }
	                } else if (object.isSprite) {
	                    if (!object.frustumCulled || _frustum.intersectsSprite(object)) {
	                        if (sortObjects) {
	                            _vector4.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix);
	                        }
	                        const geometry = objects.update(object);
	                        const material = object.material;
	                        if (material.visible) {
	                            currentRenderList.push(object, geometry, material, groupOrder, _vector4.z, null);
	                        }
	                    }
	                } else if (object.isMesh || object.isLine || object.isPoints) {
	                    if (!object.frustumCulled || _frustum.intersectsObject(object)) {
	                        const geometry = objects.update(object);
	                        const material = object.material;
	                        if (sortObjects) {
	                            if (object.boundingSphere !== undefined) {
	                                if (object.boundingSphere === null) object.computeBoundingSphere();
	                                _vector4.copy(object.boundingSphere.center);
	                            } else {
	                                if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
	                                _vector4.copy(geometry.boundingSphere.center);
	                            }
	                            _vector4.applyMatrix4(object.matrixWorld).applyMatrix4(_projScreenMatrix);
	                        }
	                        if (Array.isArray(material)) {
	                            const groups = geometry.groups;
	                            for(let i = 0, l = groups.length; i < l; i++){
	                                const group = groups[i];
	                                const groupMaterial = material[group.materialIndex];
	                                if (groupMaterial && groupMaterial.visible) {
	                                    currentRenderList.push(object, geometry, groupMaterial, groupOrder, _vector4.z, group);
	                                }
	                            }
	                        } else if (material.visible) {
	                            currentRenderList.push(object, geometry, material, groupOrder, _vector4.z, null);
	                        }
	                    }
	                }
	            }
	            const children = object.children;
	            for(let i = 0, l = children.length; i < l; i++){
	                projectObject(children[i], camera, groupOrder, sortObjects);
	            }
	        }
	        function renderScene(currentRenderList, scene, camera, viewport) {
	            const opaqueObjects = currentRenderList.opaque;
	            const transmissiveObjects = currentRenderList.transmissive;
	            const transparentObjects = currentRenderList.transparent;
	            currentRenderState.setupLightsView(camera);
	            if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, camera);
	            if (viewport) state.viewport(_currentViewport.copy(viewport));
	            if (opaqueObjects.length > 0) renderObjects(opaqueObjects, scene, camera);
	            if (transmissiveObjects.length > 0) renderObjects(transmissiveObjects, scene, camera);
	            if (transparentObjects.length > 0) renderObjects(transparentObjects, scene, camera);
	            // Ensure depth buffer writing is enabled so it can be cleared on next render
	            state.buffers.depth.setTest(true);
	            state.buffers.depth.setMask(true);
	            state.buffers.color.setMask(true);
	            state.setPolygonOffset(false);
	        }
	        function renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera) {
	            const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
	            if (overrideMaterial !== null) {
	                return;
	            }
	            if (currentRenderState.state.transmissionRenderTarget[camera.id] === undefined) {
	                currentRenderState.state.transmissionRenderTarget[camera.id] = new WebGLRenderTarget(1, 1, {
	                    generateMipmaps: true,
	                    type: extensions.has('EXT_color_buffer_half_float') || extensions.has('EXT_color_buffer_float') ? HalfFloatType : UnsignedByteType,
	                    minFilter: LinearMipmapLinearFilter,
	                    samples: 4,
	                    stencilBuffer: stencil,
	                    resolveDepthBuffer: false,
	                    resolveStencilBuffer: false,
	                    colorSpace: ColorManagement.workingColorSpace
	                });
	            // debug
	            /*
					const geometry = new PlaneGeometry();
					const material = new MeshBasicMaterial( { map: _transmissionRenderTarget.texture } );

					const mesh = new Mesh( geometry, material );
					scene.add( mesh );
					*/ }
	            const transmissionRenderTarget = currentRenderState.state.transmissionRenderTarget[camera.id];
	            const activeViewport = camera.viewport || _currentViewport;
	            transmissionRenderTarget.setSize(activeViewport.z * _this.transmissionResolutionScale, activeViewport.w * _this.transmissionResolutionScale);
	            //
	            const currentRenderTarget = _this.getRenderTarget();
	            _this.setRenderTarget(transmissionRenderTarget);
	            _this.getClearColor(_currentClearColor);
	            _currentClearAlpha = _this.getClearAlpha();
	            if (_currentClearAlpha < 1) _this.setClearColor(0xffffff, 0.5);
	            _this.clear();
	            if (_renderBackground) background.render(scene);
	            // Turn off the features which can affect the frag color for opaque objects pass.
	            // Otherwise they are applied twice in opaque objects pass and transmission objects pass.
	            const currentToneMapping = _this.toneMapping;
	            _this.toneMapping = NoToneMapping;
	            // Remove viewport from camera to avoid nested render calls resetting viewport to it (e.g Reflector).
	            // Transmission render pass requires viewport to match the transmissionRenderTarget.
	            const currentCameraViewport = camera.viewport;
	            if (camera.viewport !== undefined) camera.viewport = undefined;
	            currentRenderState.setupLightsView(camera);
	            if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, camera);
	            renderObjects(opaqueObjects, scene, camera);
	            textures.updateMultisampleRenderTarget(transmissionRenderTarget);
	            textures.updateRenderTargetMipmap(transmissionRenderTarget);
	            if (extensions.has('WEBGL_multisampled_render_to_texture') === false) {
	                let renderTargetNeedsUpdate = false;
	                for(let i = 0, l = transmissiveObjects.length; i < l; i++){
	                    const renderItem = transmissiveObjects[i];
	                    const object = renderItem.object;
	                    const geometry = renderItem.geometry;
	                    const material = renderItem.material;
	                    const group = renderItem.group;
	                    if (material.side === DoubleSide && object.layers.test(camera.layers)) {
	                        const currentSide = material.side;
	                        material.side = BackSide;
	                        material.needsUpdate = true;
	                        renderObject(object, scene, camera, geometry, material, group);
	                        material.side = currentSide;
	                        material.needsUpdate = true;
	                        renderTargetNeedsUpdate = true;
	                    }
	                }
	                if (renderTargetNeedsUpdate === true) {
	                    textures.updateMultisampleRenderTarget(transmissionRenderTarget);
	                    textures.updateRenderTargetMipmap(transmissionRenderTarget);
	                }
	            }
	            _this.setRenderTarget(currentRenderTarget);
	            _this.setClearColor(_currentClearColor, _currentClearAlpha);
	            if (currentCameraViewport !== undefined) camera.viewport = currentCameraViewport;
	            _this.toneMapping = currentToneMapping;
	        }
	        function renderObjects(renderList, scene, camera) {
	            const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
	            for(let i = 0, l = renderList.length; i < l; i++){
	                const renderItem = renderList[i];
	                const object = renderItem.object;
	                const geometry = renderItem.geometry;
	                const material = overrideMaterial === null ? renderItem.material : overrideMaterial;
	                const group = renderItem.group;
	                if (object.layers.test(camera.layers)) {
	                    renderObject(object, scene, camera, geometry, material, group);
	                }
	            }
	        }
	        function renderObject(object, scene, camera, geometry, material, group) {
	            object.onBeforeRender(_this, scene, camera, geometry, material, group);
	            object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld);
	            object.normalMatrix.getNormalMatrix(object.modelViewMatrix);
	            material.onBeforeRender(_this, scene, camera, geometry, object, group);
	            if (material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false) {
	                material.side = BackSide;
	                material.needsUpdate = true;
	                _this.renderBufferDirect(camera, scene, geometry, material, object, group);
	                material.side = FrontSide;
	                material.needsUpdate = true;
	                _this.renderBufferDirect(camera, scene, geometry, material, object, group);
	                material.side = DoubleSide;
	            } else {
	                _this.renderBufferDirect(camera, scene, geometry, material, object, group);
	            }
	            object.onAfterRender(_this, scene, camera, geometry, material, group);
	        }
	        function getProgram(material, scene, object) {
	            if (scene.isScene !== true) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
	            const materialProperties = properties.get(material);
	            const lights = currentRenderState.state.lights;
	            const shadowsArray = currentRenderState.state.shadowsArray;
	            const lightsStateVersion = lights.state.version;
	            const parameters = programCache.getParameters(material, lights.state, shadowsArray, scene, object);
	            const programCacheKey = programCache.getProgramCacheKey(parameters);
	            let programs = materialProperties.programs;
	            // always update environment and fog - changing these trigger an getProgram call, but it's possible that the program doesn't change
	            materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
	            materialProperties.fog = scene.fog;
	            materialProperties.envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || materialProperties.environment);
	            materialProperties.envMapRotation = materialProperties.environment !== null && material.envMap === null ? scene.environmentRotation : material.envMapRotation;
	            if (programs === undefined) {
	                // new material
	                material.addEventListener('dispose', onMaterialDispose);
	                programs = new Map();
	                materialProperties.programs = programs;
	            }
	            let program = programs.get(programCacheKey);
	            if (program !== undefined) {
	                // early out if program and light state is identical
	                if (materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion) {
	                    updateCommonMaterialProperties(material, parameters);
	                    return program;
	                }
	            } else {
	                parameters.uniforms = programCache.getUniforms(material);
	                material.onBeforeCompile(parameters, _this);
	                program = programCache.acquireProgram(parameters, programCacheKey);
	                programs.set(programCacheKey, program);
	                materialProperties.uniforms = parameters.uniforms;
	            }
	            const uniforms = materialProperties.uniforms;
	            if (!material.isShaderMaterial && !material.isRawShaderMaterial || material.clipping === true) {
	                uniforms.clippingPlanes = clipping.uniform;
	            }
	            updateCommonMaterialProperties(material, parameters);
	            // store the light setup it was created for
	            materialProperties.needsLights = materialNeedsLights(material);
	            materialProperties.lightsStateVersion = lightsStateVersion;
	            if (materialProperties.needsLights) {
	                // wire up the material to this renderer's lighting state
	                uniforms.ambientLightColor.value = lights.state.ambient;
	                uniforms.lightProbe.value = lights.state.probe;
	                uniforms.directionalLights.value = lights.state.directional;
	                uniforms.directionalLightShadows.value = lights.state.directionalShadow;
	                uniforms.spotLights.value = lights.state.spot;
	                uniforms.spotLightShadows.value = lights.state.spotShadow;
	                uniforms.rectAreaLights.value = lights.state.rectArea;
	                uniforms.ltc_1.value = lights.state.rectAreaLTC1;
	                uniforms.ltc_2.value = lights.state.rectAreaLTC2;
	                uniforms.pointLights.value = lights.state.point;
	                uniforms.pointLightShadows.value = lights.state.pointShadow;
	                uniforms.hemisphereLights.value = lights.state.hemi;
	                uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
	                uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
	                uniforms.spotShadowMap.value = lights.state.spotShadowMap;
	                uniforms.spotLightMatrix.value = lights.state.spotLightMatrix;
	                uniforms.spotLightMap.value = lights.state.spotLightMap;
	                uniforms.pointShadowMap.value = lights.state.pointShadowMap;
	                uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
	            // TODO (abelnation): add area lights shadow info to uniforms
	            }
	            materialProperties.currentProgram = program;
	            materialProperties.uniformsList = null;
	            return program;
	        }
	        function getUniformList(materialProperties) {
	            if (materialProperties.uniformsList === null) {
	                const progUniforms = materialProperties.currentProgram.getUniforms();
	                materialProperties.uniformsList = WebGLUniforms.seqWithValue(progUniforms.seq, materialProperties.uniforms);
	            }
	            return materialProperties.uniformsList;
	        }
	        function updateCommonMaterialProperties(material, parameters) {
	            const materialProperties = properties.get(material);
	            materialProperties.outputColorSpace = parameters.outputColorSpace;
	            materialProperties.batching = parameters.batching;
	            materialProperties.batchingColor = parameters.batchingColor;
	            materialProperties.instancing = parameters.instancing;
	            materialProperties.instancingColor = parameters.instancingColor;
	            materialProperties.instancingMorph = parameters.instancingMorph;
	            materialProperties.skinning = parameters.skinning;
	            materialProperties.morphTargets = parameters.morphTargets;
	            materialProperties.morphNormals = parameters.morphNormals;
	            materialProperties.morphColors = parameters.morphColors;
	            materialProperties.morphTargetsCount = parameters.morphTargetsCount;
	            materialProperties.numClippingPlanes = parameters.numClippingPlanes;
	            materialProperties.numIntersection = parameters.numClipIntersection;
	            materialProperties.vertexAlphas = parameters.vertexAlphas;
	            materialProperties.vertexTangents = parameters.vertexTangents;
	            materialProperties.toneMapping = parameters.toneMapping;
	        }
	        function setProgram(camera, scene, geometry, material, object) {
	            if (scene.isScene !== true) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
	            textures.resetTextureUnits();
	            const fog = scene.fog;
	            const environment = material.isMeshStandardMaterial ? scene.environment : null;
	            const colorSpace = _currentRenderTarget === null ? _this.outputColorSpace : _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.colorSpace : LinearSRGBColorSpace;
	            const envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || environment);
	            const vertexAlphas = material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4;
	            const vertexTangents = !!geometry.attributes.tangent && (!!material.normalMap || material.anisotropy > 0);
	            const morphTargets = !!geometry.morphAttributes.position;
	            const morphNormals = !!geometry.morphAttributes.normal;
	            const morphColors = !!geometry.morphAttributes.color;
	            let toneMapping = NoToneMapping;
	            if (material.toneMapped) {
	                if (_currentRenderTarget === null || _currentRenderTarget.isXRRenderTarget === true) {
	                    toneMapping = _this.toneMapping;
	                }
	            }
	            const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
	            const morphTargetsCount = morphAttribute !== undefined ? morphAttribute.length : 0;
	            const materialProperties = properties.get(material);
	            const lights = currentRenderState.state.lights;
	            if (_clippingEnabled === true) {
	                if (_localClippingEnabled === true || camera !== _currentCamera) {
	                    const useCache = camera === _currentCamera && material.id === _currentMaterialId;
	                    // we might want to call this function with some ClippingGroup
	                    // object instead of the material, once it becomes feasible
	                    // (#8465, #8379)
	                    clipping.setState(material, camera, useCache);
	                }
	            }
	            //
	            let needsProgramChange = false;
	            if (material.version === materialProperties.__version) {
	                if (materialProperties.needsLights && materialProperties.lightsStateVersion !== lights.state.version) {
	                    needsProgramChange = true;
	                } else if (materialProperties.outputColorSpace !== colorSpace) {
	                    needsProgramChange = true;
	                } else if (object.isBatchedMesh && materialProperties.batching === false) {
	                    needsProgramChange = true;
	                } else if (!object.isBatchedMesh && materialProperties.batching === true) {
	                    needsProgramChange = true;
	                } else if (object.isBatchedMesh && materialProperties.batchingColor === true && object.colorTexture === null) {
	                    needsProgramChange = true;
	                } else if (object.isBatchedMesh && materialProperties.batchingColor === false && object.colorTexture !== null) {
	                    needsProgramChange = true;
	                } else if (object.isInstancedMesh && materialProperties.instancing === false) {
	                    needsProgramChange = true;
	                } else if (!object.isInstancedMesh && materialProperties.instancing === true) {
	                    needsProgramChange = true;
	                } else if (object.isSkinnedMesh && materialProperties.skinning === false) {
	                    needsProgramChange = true;
	                } else if (!object.isSkinnedMesh && materialProperties.skinning === true) {
	                    needsProgramChange = true;
	                } else if (object.isInstancedMesh && materialProperties.instancingColor === true && object.instanceColor === null) {
	                    needsProgramChange = true;
	                } else if (object.isInstancedMesh && materialProperties.instancingColor === false && object.instanceColor !== null) {
	                    needsProgramChange = true;
	                } else if (object.isInstancedMesh && materialProperties.instancingMorph === true && object.morphTexture === null) {
	                    needsProgramChange = true;
	                } else if (object.isInstancedMesh && materialProperties.instancingMorph === false && object.morphTexture !== null) {
	                    needsProgramChange = true;
	                } else if (materialProperties.envMap !== envMap) {
	                    needsProgramChange = true;
	                } else if (material.fog === true && materialProperties.fog !== fog) {
	                    needsProgramChange = true;
	                } else if (materialProperties.numClippingPlanes !== undefined && (materialProperties.numClippingPlanes !== clipping.numPlanes || materialProperties.numIntersection !== clipping.numIntersection)) {
	                    needsProgramChange = true;
	                } else if (materialProperties.vertexAlphas !== vertexAlphas) {
	                    needsProgramChange = true;
	                } else if (materialProperties.vertexTangents !== vertexTangents) {
	                    needsProgramChange = true;
	                } else if (materialProperties.morphTargets !== morphTargets) {
	                    needsProgramChange = true;
	                } else if (materialProperties.morphNormals !== morphNormals) {
	                    needsProgramChange = true;
	                } else if (materialProperties.morphColors !== morphColors) {
	                    needsProgramChange = true;
	                } else if (materialProperties.toneMapping !== toneMapping) {
	                    needsProgramChange = true;
	                } else if (materialProperties.morphTargetsCount !== morphTargetsCount) {
	                    needsProgramChange = true;
	                }
	            } else {
	                needsProgramChange = true;
	                materialProperties.__version = material.version;
	            }
	            //
	            let program = materialProperties.currentProgram;
	            if (needsProgramChange === true) {
	                program = getProgram(material, scene, object);
	            }
	            let refreshProgram = false;
	            let refreshMaterial = false;
	            let refreshLights = false;
	            const p_uniforms = program.getUniforms(), m_uniforms = materialProperties.uniforms;
	            if (state.useProgram(program.program)) {
	                refreshProgram = true;
	                refreshMaterial = true;
	                refreshLights = true;
	            }
	            if (material.id !== _currentMaterialId) {
	                _currentMaterialId = material.id;
	                refreshMaterial = true;
	            }
	            if (refreshProgram || _currentCamera !== camera) {
	                // common camera uniforms
	                const reverseDepthBuffer = state.buffers.depth.getReversed();
	                if (reverseDepthBuffer) {
	                    _currentProjectionMatrix.copy(camera.projectionMatrix);
	                    toNormalizedProjectionMatrix(_currentProjectionMatrix);
	                    toReversedProjectionMatrix(_currentProjectionMatrix);
	                    p_uniforms.setValue(_gl, 'projectionMatrix', _currentProjectionMatrix);
	                } else {
	                    p_uniforms.setValue(_gl, 'projectionMatrix', camera.projectionMatrix);
	                }
	                p_uniforms.setValue(_gl, 'viewMatrix', camera.matrixWorldInverse);
	                const uCamPos = p_uniforms.map.cameraPosition;
	                if (uCamPos !== undefined) {
	                    uCamPos.setValue(_gl, _vector3.setFromMatrixPosition(camera.matrixWorld));
	                }
	                if (capabilities.logarithmicDepthBuffer) {
	                    p_uniforms.setValue(_gl, 'logDepthBufFC', 2.0 / (Math.log(camera.far + 1.0) / Math.LN2));
	                }
	                // consider moving isOrthographic to UniformLib and WebGLMaterials, see https://github.com/mrdoob/three.js/pull/26467#issuecomment-1645185067
	                if (material.isMeshPhongMaterial || material.isMeshToonMaterial || material.isMeshLambertMaterial || material.isMeshBasicMaterial || material.isMeshStandardMaterial || material.isShaderMaterial) {
	                    p_uniforms.setValue(_gl, 'isOrthographic', camera.isOrthographicCamera === true);
	                }
	                if (_currentCamera !== camera) {
	                    _currentCamera = camera;
	                    // lighting uniforms depend on the camera so enforce an update
	                    // now, in case this material supports lights - or later, when
	                    // the next material that does gets activated:
	                    refreshMaterial = true; // set to true on material change
	                    refreshLights = true; // remains set until update done
	                }
	            }
	            // skinning and morph target uniforms must be set even if material didn't change
	            // auto-setting of texture unit for bone and morph texture must go before other textures
	            // otherwise textures used for skinning and morphing can take over texture units reserved for other material textures
	            if (object.isSkinnedMesh) {
	                p_uniforms.setOptional(_gl, object, 'bindMatrix');
	                p_uniforms.setOptional(_gl, object, 'bindMatrixInverse');
	                const skeleton = object.skeleton;
	                if (skeleton) {
	                    if (skeleton.boneTexture === null) skeleton.computeBoneTexture();
	                    p_uniforms.setValue(_gl, 'boneTexture', skeleton.boneTexture, textures);
	                }
	            }
	            if (object.isBatchedMesh) {
	                p_uniforms.setOptional(_gl, object, 'batchingTexture');
	                p_uniforms.setValue(_gl, 'batchingTexture', object._matricesTexture, textures);
	                p_uniforms.setOptional(_gl, object, 'batchingIdTexture');
	                p_uniforms.setValue(_gl, 'batchingIdTexture', object._indirectTexture, textures);
	                p_uniforms.setOptional(_gl, object, 'batchingColorTexture');
	                if (object._colorsTexture !== null) {
	                    p_uniforms.setValue(_gl, 'batchingColorTexture', object._colorsTexture, textures);
	                }
	            }
	            const morphAttributes = geometry.morphAttributes;
	            if (morphAttributes.position !== undefined || morphAttributes.normal !== undefined || morphAttributes.color !== undefined) {
	                morphtargets.update(object, geometry, program);
	            }
	            if (refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow) {
	                materialProperties.receiveShadow = object.receiveShadow;
	                p_uniforms.setValue(_gl, 'receiveShadow', object.receiveShadow);
	            }
	            // https://github.com/mrdoob/three.js/pull/24467#issuecomment-1209031512
	            if (material.isMeshGouraudMaterial && material.envMap !== null) {
	                m_uniforms.envMap.value = envMap;
	                m_uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap.isRenderTargetTexture === false ? -1 : 1;
	            }
	            if (material.isMeshStandardMaterial && material.envMap === null && scene.environment !== null) {
	                m_uniforms.envMapIntensity.value = scene.environmentIntensity;
	            }
	            if (refreshMaterial) {
	                p_uniforms.setValue(_gl, 'toneMappingExposure', _this.toneMappingExposure);
	                if (materialProperties.needsLights) {
	                    // the current material requires lighting info
	                    // note: all lighting uniforms are always set correctly
	                    // they simply reference the renderer's state for their
	                    // values
	                    //
	                    // use the current material's .needsUpdate flags to set
	                    // the GL state when required
	                    markUniformsLightsNeedsUpdate(m_uniforms, refreshLights);
	                }
	                // refresh uniforms common to several materials
	                if (fog && material.fog === true) {
	                    materials.refreshFogUniforms(m_uniforms, fog);
	                }
	                materials.refreshMaterialUniforms(m_uniforms, material, _pixelRatio, _height, currentRenderState.state.transmissionRenderTarget[camera.id]);
	                WebGLUniforms.upload(_gl, getUniformList(materialProperties), m_uniforms, textures);
	            }
	            if (material.isShaderMaterial && material.uniformsNeedUpdate === true) {
	                WebGLUniforms.upload(_gl, getUniformList(materialProperties), m_uniforms, textures);
	                material.uniformsNeedUpdate = false;
	            }
	            if (material.isSpriteMaterial) {
	                p_uniforms.setValue(_gl, 'center', object.center);
	            }
	            // common matrices
	            p_uniforms.setValue(_gl, 'modelViewMatrix', object.modelViewMatrix);
	            p_uniforms.setValue(_gl, 'normalMatrix', object.normalMatrix);
	            p_uniforms.setValue(_gl, 'modelMatrix', object.matrixWorld);
	            // UBOs
	            if (material.isShaderMaterial || material.isRawShaderMaterial) {
	                const groups = material.uniformsGroups;
	                for(let i = 0, l = groups.length; i < l; i++){
	                    const group = groups[i];
	                    uniformsGroups.update(group, program);
	                    uniformsGroups.bind(group, program);
	                }
	            }
	            return program;
	        }
	        // If uniforms are marked as clean, they don't need to be loaded to the GPU.
	        function markUniformsLightsNeedsUpdate(uniforms, value) {
	            uniforms.ambientLightColor.needsUpdate = value;
	            uniforms.lightProbe.needsUpdate = value;
	            uniforms.directionalLights.needsUpdate = value;
	            uniforms.directionalLightShadows.needsUpdate = value;
	            uniforms.pointLights.needsUpdate = value;
	            uniforms.pointLightShadows.needsUpdate = value;
	            uniforms.spotLights.needsUpdate = value;
	            uniforms.spotLightShadows.needsUpdate = value;
	            uniforms.rectAreaLights.needsUpdate = value;
	            uniforms.hemisphereLights.needsUpdate = value;
	        }
	        function materialNeedsLights(material) {
	            return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial || material.isMeshStandardMaterial || material.isShadowMaterial || material.isShaderMaterial && material.lights === true;
	        }
	        this.getActiveCubeFace = function() {
	            return _currentActiveCubeFace;
	        };
	        this.getActiveMipmapLevel = function() {
	            return _currentActiveMipmapLevel;
	        };
	        this.getRenderTarget = function() {
	            return _currentRenderTarget;
	        };
	        this.setRenderTargetTextures = function(renderTarget, colorTexture, depthTexture) {
	            properties.get(renderTarget.texture).__webglTexture = colorTexture;
	            properties.get(renderTarget.depthTexture).__webglTexture = depthTexture;
	            const renderTargetProperties = properties.get(renderTarget);
	            renderTargetProperties.__hasExternalTextures = true;
	            renderTargetProperties.__autoAllocateDepthBuffer = depthTexture === undefined;
	            if (!renderTargetProperties.__autoAllocateDepthBuffer) {
	                // The multisample_render_to_texture extension doesn't work properly if there
	                // are midframe flushes and an external depth buffer. Disable use of the extension.
	                if (extensions.has('WEBGL_multisampled_render_to_texture') === true) {
	                    console.warn('THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided');
	                    renderTargetProperties.__useRenderToTexture = false;
	                }
	            }
	        };
	        this.setRenderTargetFramebuffer = function(renderTarget, defaultFramebuffer) {
	            const renderTargetProperties = properties.get(renderTarget);
	            renderTargetProperties.__webglFramebuffer = defaultFramebuffer;
	            renderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === undefined;
	        };
	        const _scratchFrameBuffer = _gl.createFramebuffer();
	        this.setRenderTarget = function(renderTarget, activeCubeFace = 0, activeMipmapLevel = 0) {
	            _currentRenderTarget = renderTarget;
	            _currentActiveCubeFace = activeCubeFace;
	            _currentActiveMipmapLevel = activeMipmapLevel;
	            let useDefaultFramebuffer = true;
	            let framebuffer = null;
	            let isCube = false;
	            let isRenderTarget3D = false;
	            if (renderTarget) {
	                const renderTargetProperties = properties.get(renderTarget);
	                if (renderTargetProperties.__useDefaultFramebuffer !== undefined) {
	                    // We need to make sure to rebind the framebuffer.
	                    state.bindFramebuffer(_gl.FRAMEBUFFER, null);
	                    useDefaultFramebuffer = false;
	                } else if (renderTargetProperties.__webglFramebuffer === undefined) {
	                    textures.setupRenderTarget(renderTarget);
	                } else if (renderTargetProperties.__hasExternalTextures) {
	                    // Color and depth texture must be rebound in order for the swapchain to update.
	                    textures.rebindTextures(renderTarget, properties.get(renderTarget.texture).__webglTexture, properties.get(renderTarget.depthTexture).__webglTexture);
	                } else if (renderTarget.depthBuffer) {
	                    // check if the depth texture is already bound to the frame buffer and that it's been initialized
	                    const depthTexture = renderTarget.depthTexture;
	                    if (renderTargetProperties.__boundDepthTexture !== depthTexture) {
	                        // check if the depth texture is compatible
	                        if (depthTexture !== null && properties.has(depthTexture) && (renderTarget.width !== depthTexture.image.width || renderTarget.height !== depthTexture.image.height)) {
	                            throw new Error('WebGLRenderTarget: Attached DepthTexture is initialized to the incorrect size.');
	                        }
	                        // Swap the depth buffer to the currently attached one
	                        textures.setupDepthRenderbuffer(renderTarget);
	                    }
	                }
	                const texture = renderTarget.texture;
	                if (texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture) {
	                    isRenderTarget3D = true;
	                }
	                const __webglFramebuffer = properties.get(renderTarget).__webglFramebuffer;
	                if (renderTarget.isWebGLCubeRenderTarget) {
	                    if (Array.isArray(__webglFramebuffer[activeCubeFace])) {
	                        framebuffer = __webglFramebuffer[activeCubeFace][activeMipmapLevel];
	                    } else {
	                        framebuffer = __webglFramebuffer[activeCubeFace];
	                    }
	                    isCube = true;
	                } else if (renderTarget.samples > 0 && textures.useMultisampledRTT(renderTarget) === false) {
	                    framebuffer = properties.get(renderTarget).__webglMultisampledFramebuffer;
	                } else {
	                    if (Array.isArray(__webglFramebuffer)) {
	                        framebuffer = __webglFramebuffer[activeMipmapLevel];
	                    } else {
	                        framebuffer = __webglFramebuffer;
	                    }
	                }
	                _currentViewport.copy(renderTarget.viewport);
	                _currentScissor.copy(renderTarget.scissor);
	                _currentScissorTest = renderTarget.scissorTest;
	            } else {
	                _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor();
	                _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor();
	                _currentScissorTest = _scissorTest;
	            }
	            // Use a scratch frame buffer if rendering to a mip level to avoid depth buffers
	            // being bound that are different sizes.
	            if (activeMipmapLevel !== 0) {
	                framebuffer = _scratchFrameBuffer;
	            }
	            const framebufferBound = state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
	            if (framebufferBound && useDefaultFramebuffer) {
	                state.drawBuffers(renderTarget, framebuffer);
	            }
	            state.viewport(_currentViewport);
	            state.scissor(_currentScissor);
	            state.setScissorTest(_currentScissorTest);
	            if (isCube) {
	                const textureProperties = properties.get(renderTarget.texture);
	                _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel);
	            } else if (isRenderTarget3D) {
	                const textureProperties = properties.get(renderTarget.texture);
	                const layer = activeCubeFace;
	                _gl.framebufferTextureLayer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel, layer);
	            } else if (renderTarget !== null && activeMipmapLevel !== 0) {
	                // Only bind the frame buffer if we are using a scratch frame buffer to render to a mipmap.
	                // If we rebind the texture when using a multi sample buffer then an error about inconsistent samples will be thrown.
	                const textureProperties = properties.get(renderTarget.texture);
	                _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, textureProperties.__webglTexture, activeMipmapLevel);
	            }
	            _currentMaterialId = -1; // reset current material to ensure correct uniform bindings
	        };
	        this.readRenderTargetPixels = function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex) {
	            if (!(renderTarget && renderTarget.isWebGLRenderTarget)) {
	                console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.');
	                return;
	            }
	            let framebuffer = properties.get(renderTarget).__webglFramebuffer;
	            if (renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined) {
	                framebuffer = framebuffer[activeCubeFaceIndex];
	            }
	            if (framebuffer) {
	                state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
	                try {
	                    const texture = renderTarget.texture;
	                    const textureFormat = texture.format;
	                    const textureType = texture.type;
	                    if (!capabilities.textureFormatReadable(textureFormat)) {
	                        console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.');
	                        return;
	                    }
	                    if (!capabilities.textureTypeReadable(textureType)) {
	                        console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.');
	                        return;
	                    }
	                    // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
	                    if (x >= 0 && x <= renderTarget.width - width && y >= 0 && y <= renderTarget.height - height) {
	                        _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), buffer);
	                    }
	                } finally{
	                    // restore framebuffer of current render target if necessary
	                    const framebuffer = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null;
	                    state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
	                }
	            }
	        };
	        this.readRenderTargetPixelsAsync = async function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex) {
	            if (!(renderTarget && renderTarget.isWebGLRenderTarget)) {
	                throw new Error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.');
	            }
	            let framebuffer = properties.get(renderTarget).__webglFramebuffer;
	            if (renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined) {
	                framebuffer = framebuffer[activeCubeFaceIndex];
	            }
	            if (framebuffer) {
	                const texture = renderTarget.texture;
	                const textureFormat = texture.format;
	                const textureType = texture.type;
	                if (!capabilities.textureFormatReadable(textureFormat)) {
	                    throw new Error('THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in RGBA or implementation defined format.');
	                }
	                if (!capabilities.textureTypeReadable(textureType)) {
	                    throw new Error('THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in UnsignedByteType or implementation defined type.');
	                }
	                // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
	                if (x >= 0 && x <= renderTarget.width - width && y >= 0 && y <= renderTarget.height - height) {
	                    // set the active frame buffer to the one we want to read
	                    state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
	                    const glBuffer = _gl.createBuffer();
	                    _gl.bindBuffer(_gl.PIXEL_PACK_BUFFER, glBuffer);
	                    _gl.bufferData(_gl.PIXEL_PACK_BUFFER, buffer.byteLength, _gl.STREAM_READ);
	                    _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), 0);
	                    // reset the frame buffer to the currently set buffer before waiting
	                    const currFramebuffer = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null;
	                    state.bindFramebuffer(_gl.FRAMEBUFFER, currFramebuffer);
	                    // check if the commands have finished every 8 ms
	                    const sync = _gl.fenceSync(_gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
	                    _gl.flush();
	                    await probeAsync(_gl, sync, 4);
	                    // read the data and delete the buffer
	                    _gl.bindBuffer(_gl.PIXEL_PACK_BUFFER, glBuffer);
	                    _gl.getBufferSubData(_gl.PIXEL_PACK_BUFFER, 0, buffer);
	                    _gl.deleteBuffer(glBuffer);
	                    _gl.deleteSync(sync);
	                    return buffer;
	                } else {
	                    throw new Error('THREE.WebGLRenderer.readRenderTargetPixelsAsync: requested read bounds are out of range.');
	                }
	            }
	        };
	        this.copyFramebufferToTexture = function(texture, position = null, level = 0) {
	            // support previous signature with position first
	            if (texture.isTexture !== true) {
	                // @deprecated, r165
	                warnOnce('WebGLRenderer: copyFramebufferToTexture function signature has changed.');
	                position = arguments[0] || null;
	                texture = arguments[1];
	            }
	            const levelScale = Math.pow(2, -level);
	            const width = Math.floor(texture.image.width * levelScale);
	            const height = Math.floor(texture.image.height * levelScale);
	            const x = position !== null ? position.x : 0;
	            const y = position !== null ? position.y : 0;
	            textures.setTexture2D(texture, 0);
	            _gl.copyTexSubImage2D(_gl.TEXTURE_2D, level, 0, 0, x, y, width, height);
	            state.unbindTexture();
	        };
	        const _srcFramebuffer = _gl.createFramebuffer();
	        const _dstFramebuffer = _gl.createFramebuffer();
	        this.copyTextureToTexture = function(srcTexture, dstTexture, srcRegion = null, dstPosition = null, srcLevel = 0, dstLevel = null) {
	            // support previous signature with dstPosition first
	            if (srcTexture.isTexture !== true) {
	                // @deprecated, r165
	                warnOnce('WebGLRenderer: copyTextureToTexture function signature has changed.');
	                dstPosition = arguments[0] || null;
	                srcTexture = arguments[1];
	                dstTexture = arguments[2];
	                dstLevel = arguments[3] || 0;
	                srcRegion = null;
	            }
	            // support the previous signature with just a single dst mipmap level
	            if (dstLevel === null) {
	                if (srcLevel !== 0) {
	                    // @deprecated, r171
	                    warnOnce('WebGLRenderer: copyTextureToTexture function signature has changed to support src and dst mipmap levels.');
	                    dstLevel = srcLevel;
	                    srcLevel = 0;
	                } else {
	                    dstLevel = 0;
	                }
	            }
	            // gather the necessary dimensions to copy
	            let width, height, depth, minX, minY, minZ;
	            let dstX, dstY, dstZ;
	            const image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[dstLevel] : srcTexture.image;
	            if (srcRegion !== null) {
	                width = srcRegion.max.x - srcRegion.min.x;
	                height = srcRegion.max.y - srcRegion.min.y;
	                depth = srcRegion.isBox3 ? srcRegion.max.z - srcRegion.min.z : 1;
	                minX = srcRegion.min.x;
	                minY = srcRegion.min.y;
	                minZ = srcRegion.isBox3 ? srcRegion.min.z : 0;
	            } else {
	                const levelScale = Math.pow(2, -srcLevel);
	                width = Math.floor(image.width * levelScale);
	                height = Math.floor(image.height * levelScale);
	                if (srcTexture.isDataArrayTexture) {
	                    depth = image.depth;
	                } else if (srcTexture.isData3DTexture) {
	                    depth = Math.floor(image.depth * levelScale);
	                } else {
	                    depth = 1;
	                }
	                minX = 0;
	                minY = 0;
	                minZ = 0;
	            }
	            if (dstPosition !== null) {
	                dstX = dstPosition.x;
	                dstY = dstPosition.y;
	                dstZ = dstPosition.z;
	            } else {
	                dstX = 0;
	                dstY = 0;
	                dstZ = 0;
	            }
	            // Set up the destination target
	            const glFormat = utils.convert(dstTexture.format);
	            const glType = utils.convert(dstTexture.type);
	            let glTarget;
	            if (dstTexture.isData3DTexture) {
	                textures.setTexture3D(dstTexture, 0);
	                glTarget = _gl.TEXTURE_3D;
	            } else if (dstTexture.isDataArrayTexture || dstTexture.isCompressedArrayTexture) {
	                textures.setTexture2DArray(dstTexture, 0);
	                glTarget = _gl.TEXTURE_2D_ARRAY;
	            } else {
	                textures.setTexture2D(dstTexture, 0);
	                glTarget = _gl.TEXTURE_2D;
	            }
	            _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY);
	            _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha);
	            _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment);
	            // used for copying data from cpu
	            const currentUnpackRowLen = _gl.getParameter(_gl.UNPACK_ROW_LENGTH);
	            const currentUnpackImageHeight = _gl.getParameter(_gl.UNPACK_IMAGE_HEIGHT);
	            const currentUnpackSkipPixels = _gl.getParameter(_gl.UNPACK_SKIP_PIXELS);
	            const currentUnpackSkipRows = _gl.getParameter(_gl.UNPACK_SKIP_ROWS);
	            const currentUnpackSkipImages = _gl.getParameter(_gl.UNPACK_SKIP_IMAGES);
	            _gl.pixelStorei(_gl.UNPACK_ROW_LENGTH, image.width);
	            _gl.pixelStorei(_gl.UNPACK_IMAGE_HEIGHT, image.height);
	            _gl.pixelStorei(_gl.UNPACK_SKIP_PIXELS, minX);
	            _gl.pixelStorei(_gl.UNPACK_SKIP_ROWS, minY);
	            _gl.pixelStorei(_gl.UNPACK_SKIP_IMAGES, minZ);
	            // set up the src texture
	            const isSrc3D = srcTexture.isDataArrayTexture || srcTexture.isData3DTexture;
	            const isDst3D = dstTexture.isDataArrayTexture || dstTexture.isData3DTexture;
	            if (srcTexture.isDepthTexture) {
	                const srcTextureProperties = properties.get(srcTexture);
	                const dstTextureProperties = properties.get(dstTexture);
	                const srcRenderTargetProperties = properties.get(srcTextureProperties.__renderTarget);
	                const dstRenderTargetProperties = properties.get(dstTextureProperties.__renderTarget);
	                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, srcRenderTargetProperties.__webglFramebuffer);
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, dstRenderTargetProperties.__webglFramebuffer);
	                for(let i = 0; i < depth; i++){
	                    // if the source or destination are a 3d target then a layer needs to be bound
	                    if (isSrc3D) {
	                        _gl.framebufferTextureLayer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, properties.get(srcTexture).__webglTexture, srcLevel, minZ + i);
	                        _gl.framebufferTextureLayer(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, properties.get(dstTexture).__webglTexture, dstLevel, dstZ + i);
	                    }
	                    _gl.blitFramebuffer(minX, minY, width, height, dstX, dstY, width, height, _gl.DEPTH_BUFFER_BIT, _gl.NEAREST);
	                }
	                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null);
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null);
	            } else if (srcLevel !== 0 || srcTexture.isRenderTargetTexture || properties.has(srcTexture)) {
	                // get the appropriate frame buffers
	                const srcTextureProperties = properties.get(srcTexture);
	                const dstTextureProperties = properties.get(dstTexture);
	                // bind the frame buffer targets
	                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, _srcFramebuffer);
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, _dstFramebuffer);
	                for(let i = 0; i < depth; i++){
	                    // assign the correct layers and mip maps to the frame buffers
	                    if (isSrc3D) {
	                        _gl.framebufferTextureLayer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, srcTextureProperties.__webglTexture, srcLevel, minZ + i);
	                    } else {
	                        _gl.framebufferTexture2D(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, srcTextureProperties.__webglTexture, srcLevel);
	                    }
	                    if (isDst3D) {
	                        _gl.framebufferTextureLayer(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, dstTextureProperties.__webglTexture, dstLevel, dstZ + i);
	                    } else {
	                        _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, dstTextureProperties.__webglTexture, dstLevel);
	                    }
	                    // copy the data using the fastest function that can achieve the copy
	                    if (srcLevel !== 0) {
	                        _gl.blitFramebuffer(minX, minY, width, height, dstX, dstY, width, height, _gl.COLOR_BUFFER_BIT, _gl.NEAREST);
	                    } else if (isDst3D) {
	                        _gl.copyTexSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ + i, minX, minY, width, height);
	                    } else {
	                        _gl.copyTexSubImage2D(glTarget, dstLevel, dstX, dstY, minX, minY, width, height);
	                    }
	                }
	                // unbind read, draw buffers
	                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null);
	                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null);
	            } else {
	                if (isDst3D) {
	                    // copy data into the 3d texture
	                    if (srcTexture.isDataTexture || srcTexture.isData3DTexture) {
	                        _gl.texSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, glFormat, glType, image.data);
	                    } else if (dstTexture.isCompressedArrayTexture) {
	                        _gl.compressedTexSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, glFormat, image.data);
	                    } else {
	                        _gl.texSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, glFormat, glType, image);
	                    }
	                } else {
	                    // copy data into the 2d texture
	                    if (srcTexture.isDataTexture) {
	                        _gl.texSubImage2D(_gl.TEXTURE_2D, dstLevel, dstX, dstY, width, height, glFormat, glType, image.data);
	                    } else if (srcTexture.isCompressedTexture) {
	                        _gl.compressedTexSubImage2D(_gl.TEXTURE_2D, dstLevel, dstX, dstY, image.width, image.height, glFormat, image.data);
	                    } else {
	                        _gl.texSubImage2D(_gl.TEXTURE_2D, dstLevel, dstX, dstY, width, height, glFormat, glType, image);
	                    }
	                }
	            }
	            // reset values
	            _gl.pixelStorei(_gl.UNPACK_ROW_LENGTH, currentUnpackRowLen);
	            _gl.pixelStorei(_gl.UNPACK_IMAGE_HEIGHT, currentUnpackImageHeight);
	            _gl.pixelStorei(_gl.UNPACK_SKIP_PIXELS, currentUnpackSkipPixels);
	            _gl.pixelStorei(_gl.UNPACK_SKIP_ROWS, currentUnpackSkipRows);
	            _gl.pixelStorei(_gl.UNPACK_SKIP_IMAGES, currentUnpackSkipImages);
	            // Generate mipmaps only when copying level 0
	            if (dstLevel === 0 && dstTexture.generateMipmaps) {
	                _gl.generateMipmap(glTarget);
	            }
	            state.unbindTexture();
	        };
	        this.copyTextureToTexture3D = function(srcTexture, dstTexture, srcRegion = null, dstPosition = null, level = 0) {
	            // support previous signature with source box first
	            if (srcTexture.isTexture !== true) {
	                // @deprecated, r165
	                warnOnce('WebGLRenderer: copyTextureToTexture3D function signature has changed.');
	                srcRegion = arguments[0] || null;
	                dstPosition = arguments[1] || null;
	                srcTexture = arguments[2];
	                dstTexture = arguments[3];
	                level = arguments[4] || 0;
	            }
	            // @deprecated, r170
	            warnOnce('WebGLRenderer: copyTextureToTexture3D function has been deprecated. Use "copyTextureToTexture" instead.');
	            return this.copyTextureToTexture(srcTexture, dstTexture, srcRegion, dstPosition, level);
	        };
	        this.initRenderTarget = function(target) {
	            if (properties.get(target).__webglFramebuffer === undefined) {
	                textures.setupRenderTarget(target);
	            }
	        };
	        this.initTexture = function(texture) {
	            if (texture.isCubeTexture) {
	                textures.setTextureCube(texture, 0);
	            } else if (texture.isData3DTexture) {
	                textures.setTexture3D(texture, 0);
	            } else if (texture.isDataArrayTexture || texture.isCompressedArrayTexture) {
	                textures.setTexture2DArray(texture, 0);
	            } else {
	                textures.setTexture2D(texture, 0);
	            }
	            state.unbindTexture();
	        };
	        this.resetState = function() {
	            _currentActiveCubeFace = 0;
	            _currentActiveMipmapLevel = 0;
	            _currentRenderTarget = null;
	            state.reset();
	            bindingStates.reset();
	        };
	        if (typeof __THREE_DEVTOOLS__ !== 'undefined') {
	            __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent('observe', {
	                detail: this
	            }));
	        }
	    }
	}

	/**
	 * @license
	 * Copyright 2017 Google LLC
	 * SPDX-License-Identifier: BSD-3-Clause
	 */ var _t;
	const t$1 = globalThis, i$2 = t$1.trustedTypes, s = i$2 ? i$2.createPolicy("lit-html", {
	    createHTML: (t)=>t
	}) : void 0, e = "$lit$", h = `lit$${Math.random().toFixed(9).slice(2)}$`, o = "?" + h, n$1 = `<${o}>`, r$1 = document, l = ()=>r$1.createComment(""), c$1 = (t)=>null === t || "object" != typeof t && "function" != typeof t, a$1 = Array.isArray, u$1 = (t)=>a$1(t) || "function" == typeof t?.[Symbol.iterator], d = "[ \t\n\f\r]", f = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, v = /-->/g, _ = />/g, m = RegExp(`>|${d}(?:([^\\s"'>=/]+)(${d}*=${d}*(?:[^ \t\n\f\r"'\`<>=]|("|')|))|$)`, "g"), p = /'/g, g$2 = /"/g, $ = /^(?:script|style|textarea|title)$/i, y = (t)=>(i, ...s)=>({
	            _$litType$: t,
	            strings: i,
	            values: s
	        }), x$1 = y(1), T$1 = Symbol.for("lit-noChange"), E = Symbol.for("lit-nothing"), A$1 = new WeakMap, C$2 = r$1.createTreeWalker(r$1, 129);
	function P(t, i) {
	    if (!a$1(t) || !t.hasOwnProperty("raw")) throw Error("invalid template strings array");
	    return void 0 !== s ? s.createHTML(i) : i;
	}
	const V = (t, i)=>{
	    const s = t.length - 1, o = [];
	    let r, l = 2 === i ? "<svg>" : 3 === i ? "<math>" : "", c = f;
	    for(let i = 0; i < s; i++){
	        const s = t[i];
	        let a, u, d = -1, y = 0;
	        for(; y < s.length && (c.lastIndex = y, u = c.exec(s), null !== u);)y = c.lastIndex, c === f ? "!--" === u[1] ? c = v : void 0 !== u[1] ? c = _ : void 0 !== u[2] ? ($.test(u[2]) && (r = RegExp("</" + u[2], "g")), c = m) : void 0 !== u[3] && (c = m) : c === m ? ">" === u[0] ? (c = r ?? f, d = -1) : void 0 === u[1] ? d = -2 : (d = c.lastIndex - u[2].length, a = u[1], c = void 0 === u[3] ? m : '"' === u[3] ? g$2 : p) : c === g$2 || c === p ? c = m : c === v || c === _ ? c = f : (c = m, r = void 0);
	        const x = c === m && t[i + 1].startsWith("/>") ? " " : "";
	        l += c === f ? s + n$1 : d >= 0 ? (o.push(a), s.slice(0, d) + e + s.slice(d) + h + x) : s + h + (-2 === d ? i : x);
	    }
	    return [
	        P(t, l + (t[s] || "<?>") + (2 === i ? "</svg>" : 3 === i ? "</math>" : "")),
	        o
	    ];
	};
	class N {
	    static createElement(t, i) {
	        const s = r$1.createElement("template");
	        return s.innerHTML = t, s;
	    }
	    constructor({ strings: t, _$litType$: s }, n){
	        let r;
	        this.parts = [];
	        let c = 0, a = 0;
	        const u = t.length - 1, d = this.parts, [f, v] = V(t, s);
	        if (this.el = N.createElement(f, n), C$2.currentNode = this.el.content, 2 === s || 3 === s) {
	            const t = this.el.content.firstChild;
	            t.replaceWith(...t.childNodes);
	        }
	        for(; null !== (r = C$2.nextNode()) && d.length < u;){
	            if (1 === r.nodeType) {
	                if (r.hasAttributes()) for (const t of r.getAttributeNames())if (t.endsWith(e)) {
	                    const i = v[a++], s = r.getAttribute(t).split(h), e = /([.?@])?(.*)/.exec(i);
	                    d.push({
	                        type: 1,
	                        index: c,
	                        name: e[2],
	                        strings: s,
	                        ctor: "." === e[1] ? H : "?" === e[1] ? I$1 : "@" === e[1] ? L : k
	                    }), r.removeAttribute(t);
	                } else t.startsWith(h) && (d.push({
	                    type: 6,
	                    index: c
	                }), r.removeAttribute(t));
	                if ($.test(r.tagName)) {
	                    const t = r.textContent.split(h), s = t.length - 1;
	                    if (s > 0) {
	                        r.textContent = i$2 ? i$2.emptyScript : "";
	                        for(let i = 0; i < s; i++)r.append(t[i], l()), C$2.nextNode(), d.push({
	                            type: 2,
	                            index: ++c
	                        });
	                        r.append(t[s], l());
	                    }
	                }
	            } else if (8 === r.nodeType) if (r.data === o) d.push({
	                type: 2,
	                index: c
	            });
	            else {
	                let t = -1;
	                for(; -1 !== (t = r.data.indexOf(h, t + 1));)d.push({
	                    type: 7,
	                    index: c
	                }), t += h.length - 1;
	            }
	            c++;
	        }
	    }
	}
	function S(t, i, s = t, e) {
	    var _s;
	    if (i === T$1) return i;
	    let h = void 0 !== e ? s._$Co?.[e] : s._$Cl;
	    const o = c$1(i) ? void 0 : i._$litDirective$;
	    return h?.constructor !== o && (h?._$AO?.(false), void 0 === o ? h = void 0 : (h = new o(t), h._$AT(t, s, e)), void 0 !== e ? ((_s = s)._$Co ?? (_s._$Co = []))[e] = h : s._$Cl = h), void 0 !== h && (i = S(t, h._$AS(t, i.values), h, e)), i;
	}
	class M {
	    get parentNode() {
	        return this._$AM.parentNode;
	    }
	    get _$AU() {
	        return this._$AM._$AU;
	    }
	    u(t) {
	        const { el: { content: i }, parts: s } = this._$AD, e = (t?.creationScope ?? r$1).importNode(i, true);
	        C$2.currentNode = e;
	        let h = C$2.nextNode(), o = 0, n = 0, l = s[0];
	        for(; void 0 !== l;){
	            if (o === l.index) {
	                let i;
	                2 === l.type ? i = new R$1(h, h.nextSibling, this, t) : 1 === l.type ? i = new l.ctor(h, l.name, l.strings, this, t) : 6 === l.type && (i = new z(h, this, t)), this._$AV.push(i), l = s[++n];
	            }
	            o !== l?.index && (h = C$2.nextNode(), o++);
	        }
	        return C$2.currentNode = r$1, e;
	    }
	    p(t) {
	        let i = 0;
	        for (const s of this._$AV) void 0 !== s && (void 0 !== s.strings ? (s._$AI(t, s, i), i += s.strings.length - 2) : s._$AI(t[i])), i++;
	    }
	    constructor(t, i){
	        this._$AV = [], this._$AN = void 0, this._$AD = t, this._$AM = i;
	    }
	}
	let R$1 = class R {
	    get _$AU() {
	        return this._$AM?._$AU ?? this._$Cv;
	    }
	    get parentNode() {
	        let t = this._$AA.parentNode;
	        const i = this._$AM;
	        return void 0 !== i && 11 === t?.nodeType && (t = i.parentNode), t;
	    }
	    get startNode() {
	        return this._$AA;
	    }
	    get endNode() {
	        return this._$AB;
	    }
	    _$AI(t, i = this) {
	        t = S(this, t, i), c$1(t) ? t === E || null == t || "" === t ? (this._$AH !== E && this._$AR(), this._$AH = E) : t !== this._$AH && t !== T$1 && this._(t) : void 0 !== t._$litType$ ? this.$(t) : void 0 !== t.nodeType ? this.T(t) : u$1(t) ? this.k(t) : this._(t);
	    }
	    O(t) {
	        return this._$AA.parentNode.insertBefore(t, this._$AB);
	    }
	    T(t) {
	        this._$AH !== t && (this._$AR(), this._$AH = this.O(t));
	    }
	    _(t) {
	        this._$AH !== E && c$1(this._$AH) ? this._$AA.nextSibling.data = t : this.T(r$1.createTextNode(t)), this._$AH = t;
	    }
	    $(t) {
	        const { values: i, _$litType$: s } = t, e = "number" == typeof s ? this._$AC(t) : (void 0 === s.el && (s.el = N.createElement(P(s.h, s.h[0]), this.options)), s);
	        if (this._$AH?._$AD === e) this._$AH.p(i);
	        else {
	            const t = new M(e, this), s = t.u(this.options);
	            t.p(i), this.T(s), this._$AH = t;
	        }
	    }
	    _$AC(t) {
	        let i = A$1.get(t.strings);
	        return void 0 === i && A$1.set(t.strings, i = new N(t)), i;
	    }
	    k(t) {
	        a$1(this._$AH) || (this._$AH = [], this._$AR());
	        const i = this._$AH;
	        let s, e = 0;
	        for (const h of t)e === i.length ? i.push(s = new R(this.O(l()), this.O(l()), this, this.options)) : s = i[e], s._$AI(h), e++;
	        e < i.length && (this._$AR(s && s._$AB.nextSibling, e), i.length = e);
	    }
	    _$AR(t = this._$AA.nextSibling, i) {
	        for(this._$AP?.(false, true, i); t && t !== this._$AB;){
	            const i = t.nextSibling;
	            t.remove(), t = i;
	        }
	    }
	    setConnected(t) {
	        void 0 === this._$AM && (this._$Cv = t, this._$AP?.(t));
	    }
	    constructor(t, i, s, e){
	        this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t, this._$AB = i, this._$AM = s, this.options = e, this._$Cv = e?.isConnected ?? true;
	    }
	};
	class k {
	    get tagName() {
	        return this.element.tagName;
	    }
	    get _$AU() {
	        return this._$AM._$AU;
	    }
	    _$AI(t, i = this, s, e) {
	        const h = this.strings;
	        let o = false;
	        if (void 0 === h) t = S(this, t, i, 0), o = !c$1(t) || t !== this._$AH && t !== T$1, o && (this._$AH = t);
	        else {
	            const e = t;
	            let n, r;
	            for(t = h[0], n = 0; n < h.length - 1; n++)r = S(this, e[s + n], i, n), r === T$1 && (r = this._$AH[n]), o || (o = !c$1(r) || r !== this._$AH[n]), r === E ? t = E : t !== E && (t += (r ?? "") + h[n + 1]), this._$AH[n] = r;
	        }
	        o && !e && this.j(t);
	    }
	    j(t) {
	        t === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t ?? "");
	    }
	    constructor(t, i, s, e, h){
	        this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t, this.name = i, this._$AM = e, this.options = h, s.length > 2 || "" !== s[0] || "" !== s[1] ? (this._$AH = Array(s.length - 1).fill(new String), this.strings = s) : this._$AH = E;
	    }
	}
	class H extends k {
	    j(t) {
	        this.element[this.name] = t === E ? void 0 : t;
	    }
	    constructor(){
	        super(...arguments), this.type = 3;
	    }
	}
	let I$1 = class I extends k {
	    j(t) {
	        this.element.toggleAttribute(this.name, !!t && t !== E);
	    }
	    constructor(){
	        super(...arguments), this.type = 4;
	    }
	};
	class L extends k {
	    _$AI(t, i = this) {
	        if ((t = S(this, t, i, 0) ?? E) === T$1) return;
	        const s = this._$AH, e = t === E && s !== E || t.capture !== s.capture || t.once !== s.once || t.passive !== s.passive, h = t !== E && (s === E || e);
	        e && this.element.removeEventListener(this.name, this, s), h && this.element.addEventListener(this.name, this, t), this._$AH = t;
	    }
	    handleEvent(t) {
	        "function" == typeof this._$AH ? this._$AH.call(this.options?.host ?? this.element, t) : this._$AH.handleEvent(t);
	    }
	    constructor(t, i, s, e, h){
	        super(t, i, s, e, h), this.type = 5;
	    }
	}
	class z {
	    get _$AU() {
	        return this._$AM._$AU;
	    }
	    _$AI(t) {
	        S(this, t);
	    }
	    constructor(t, i, s){
	        this.element = t, this.type = 6, this._$AN = void 0, this._$AM = i, this.options = s;
	    }
	}
	const j = t$1.litHtmlPolyfillSupport;
	j?.(N, R$1), ((_t = t$1).litHtmlVersions ?? (_t.litHtmlVersions = [])).push("3.2.1");
	const B$1 = (t, i, s)=>{
	    const e = s?.renderBefore ?? i;
	    let h = e._$litPart$;
	    if (void 0 === h) {
	        const t = s?.renderBefore ?? null;
	        e._$litPart$ = h = new R$1(i.insertBefore(l(), t), t, void 0, s ?? {});
	    }
	    return h._$AI(t), h;
	};

	var _globalThis;
	/**
	 * @license
	 * Copyright 2017 Google LLC
	 * SPDX-License-Identifier: BSD-3-Clause
	 */ class r extends b$1 {
	    createRenderRoot() {
	        var _this_renderOptions;
	        const t = super.createRenderRoot();
	        return (_this_renderOptions = this.renderOptions).renderBefore ?? (_this_renderOptions.renderBefore = t.firstChild), t;
	    }
	    update(t) {
	        const s = this.render();
	        this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t), this._$Do = B$1(s, this.renderRoot, this.renderOptions);
	    }
	    connectedCallback() {
	        super.connectedCallback(), this._$Do?.setConnected(true);
	    }
	    disconnectedCallback() {
	        super.disconnectedCallback(), this._$Do?.setConnected(false);
	    }
	    render() {
	        return T$1;
	    }
	    constructor(){
	        super(...arguments), this.renderOptions = {
	            host: this
	        }, this._$Do = void 0;
	    }
	}
	r._$litElement$ = true, r["finalized"] = true, globalThis.litElementHydrateSupport?.({
	    LitElement: r
	});
	const i$1 = globalThis.litElementPolyfillSupport;
	i$1?.({
	    LitElement: r
	});
	((_globalThis = globalThis).litElementVersions ?? (_globalThis.litElementVersions = [])).push("4.1.1");

	const HAS_WEBXR_DEVICE_API = navigator.xr != null && self.XRSession != null && navigator.xr.isSessionSupported != null;
	const HAS_WEBXR_HIT_TEST_API = HAS_WEBXR_DEVICE_API && self.XRSession.prototype.requestHitTestSource != null;
	const HAS_RESIZE_OBSERVER = self.ResizeObserver != null;
	const HAS_INTERSECTION_OBSERVER = self.IntersectionObserver != null;
	const IS_WEBXR_AR_CANDIDATE = HAS_WEBXR_HIT_TEST_API;
	(()=>{
	    const userAgent = navigator.userAgent || navigator.vendor || self.opera;
	    let check = false;
	    if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(userAgent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(userAgent.substr(0, 4))) {
	        check = true;
	    }
	    return check;
	})();
	const IS_ANDROID = /android/i.test(navigator.userAgent);
	const IS_IOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !self.MSStream || navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
	const IS_FIREFOX = /firefox/i.test(navigator.userAgent);
	const IS_OCULUS = /OculusBrowser/.test(navigator.userAgent);
	const IS_SCENEVIEWER_CANDIDATE = IS_ANDROID && !IS_FIREFOX && !IS_OCULUS;
	const IS_WKWEBVIEW = Boolean(window.webkit && window.webkit.messageHandlers);
	const IS_AR_QUICKLOOK_CANDIDATE = (()=>{
	    if (IS_IOS) {
	        if (!IS_WKWEBVIEW) {
	            const tempAnchor = document.createElement('a');
	            return Boolean(tempAnchor.relList && tempAnchor.relList.supports && tempAnchor.relList.supports('ar'));
	        } else {
	            return Boolean(/CriOS\/|EdgiOS\/|FxiOS\/|GSA\/|DuckDuckGo\//.test(navigator.userAgent));
	        }
	    } else {
	        return false;
	    }
	})();

	const deserializeUrl = (url)=>!!url && url !== 'null' ? toFullUrl(url) : null;
	const assertIsArCandidate = ()=>{
	    if (IS_WEBXR_AR_CANDIDATE) {
	        return;
	    }
	    const missingApis = [];
	    if (!HAS_WEBXR_DEVICE_API) {
	        missingApis.push('WebXR Device API');
	    }
	    if (!HAS_WEBXR_HIT_TEST_API) {
	        missingApis.push('WebXR Hit Test API');
	    }
	    throw new Error(`The following APIs are required for AR, but are missing in this browser: ${missingApis.join(', ')}`);
	};
	 const toFullUrl = (partialUrl)=>{
	    const url = new URL(partialUrl, window.location.toString());
	    return url.toString();
	};
	 const throttle = (fn, ms)=>{
	    let timer = null;
	    const throttled = (...args)=>{
	        if (timer != null) {
	            return;
	        }
	        fn(...args);
	        timer = self.setTimeout(()=>timer = null, ms);
	    };
	    throttled.flush = ()=>{
	        if (timer != null) {
	            self.clearTimeout(timer);
	            timer = null;
	        }
	    };
	    return throttled;
	};
	const debounce = (fn, ms)=>{
	    let timer = null;
	    return (...args)=>{
	        if (timer != null) {
	            self.clearTimeout(timer);
	        }
	        timer = self.setTimeout(()=>{
	            timer = null;
	            fn(...args);
	        }, ms);
	    };
	};
	 const clamp = (value, lowerLimit, upperLimit)=>Math.max(lowerLimit, Math.min(upperLimit, value));
	 const isDebugMode = (()=>{
	    const debugQueryParameterName = 'model-viewer-debug-mode';
	    const debugQueryParameter = new RegExp(`[?&]${debugQueryParameterName}(&|$)`);
	    return ()=>self.ModelViewerElement && self.ModelViewerElement.debugMode || self.location && self.location.search && self.location.search.match(debugQueryParameter);
	})();
	const timePasses = (ms = 0)=>new Promise((resolve)=>setTimeout(resolve, ms));
	 const waitForEvent = (target, eventName, predicate = null)=>new Promise((resolve)=>{
	        function handler(event) {
	            if (!predicate || predicate(event)) {
	                resolve(event);
	                target.removeEventListener(eventName, handler);
	            }
	        }
	        target.addEventListener(eventName, handler);
	    });

	var __decorate$7 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	const BASE_OPACITY = 0.5;
	const DEFAULT_SHADOW_INTENSITY = 0.0;
	const DEFAULT_SHADOW_SOFTNESS = 1.0;
	const DEFAULT_EXPOSURE = 1.0;
	const $currentEnvironmentMap = Symbol('currentEnvironmentMap');
	const $currentBackground = Symbol('currentBackground');
	const $updateEnvironment = Symbol('updateEnvironment');
	const $cancelEnvironmentUpdate = Symbol('cancelEnvironmentUpdate');
	const EnvironmentMixin = (ModelViewerElement)=>{
	    var _a, _b, _c;
	    class EnvironmentModelViewerElement extends ModelViewerElement {
	        updated(changedProperties) {
	            super.updated(changedProperties);
	            if (changedProperties.has('shadowIntensity')) {
	                this[$scene].setShadowIntensity(this.shadowIntensity * BASE_OPACITY);
	                this[$needsRender]();
	            }
	            if (changedProperties.has('shadowSoftness')) {
	                this[$scene].setShadowSoftness(this.shadowSoftness);
	                this[$needsRender]();
	            }
	            if (changedProperties.has('exposure')) {
	                this[$scene].exposure = this.exposure;
	                this[$needsRender]();
	            }
	            if (changedProperties.has('toneMapping')) {
	                this[$scene].toneMapping = this.toneMapping === 'aces' ? ACESFilmicToneMapping : this.toneMapping === 'agx' ? AgXToneMapping : this.toneMapping === 'reinhard' ? ReinhardToneMapping : this.toneMapping === 'cineon' ? CineonToneMapping : this.toneMapping === 'linear' ? LinearToneMapping : this.toneMapping === 'none' ? NoToneMapping : NeutralToneMapping;
	                this[$needsRender]();
	            }
	            if ((changedProperties.has('environmentImage') || changedProperties.has('skyboxImage')) && this[$shouldAttemptPreload]()) {
	                this[$updateEnvironment]();
	            }
	            if (changedProperties.has('skyboxHeight')) {
	                this[$scene].setGroundedSkybox();
	                this[$needsRender]();
	            }
	        }
	        hasBakedShadow() {
	            return this[$scene].bakedShadows.size > 0;
	        }
	        async [(_a = $currentEnvironmentMap, _b = $currentBackground, _c = $cancelEnvironmentUpdate, $updateEnvironment)]() {
	            const { skyboxImage, environmentImage } = this;
	            if (this[$cancelEnvironmentUpdate] != null) {
	                this[$cancelEnvironmentUpdate]();
	                this[$cancelEnvironmentUpdate] = null;
	            }
	            const { textureUtils } = this[$renderer];
	            if (textureUtils == null) {
	                return;
	            }
	            const updateEnvProgress = this[$progressTracker].beginActivity('environment-update');
	            try {
	                const { environmentMap, skybox } = await textureUtils.generateEnvironmentMapAndSkybox(deserializeUrl(skyboxImage), environmentImage, (progress)=>updateEnvProgress(clamp(progress, 0, 1)), this.withCredentials);
	                if (this[$currentEnvironmentMap] !== environmentMap) {
	                    this[$currentEnvironmentMap] = environmentMap;
	                    this.dispatchEvent(new CustomEvent('environment-change'));
	                }
	                if (skybox != null) {
	                    this[$currentBackground] = skybox.name === environmentMap.name ? environmentMap : skybox;
	                } else {
	                    this[$currentBackground] = null;
	                }
	                this[$scene].setEnvironmentAndSkybox(this[$currentEnvironmentMap], this[$currentBackground]);
	            } catch (errorOrPromise) {
	                if (errorOrPromise instanceof Error) {
	                    this[$scene].setEnvironmentAndSkybox(null, null);
	                    throw errorOrPromise;
	                }
	            } finally{
	                updateEnvProgress(1.0);
	            }
	        }
	        constructor(){
	            super(...arguments);
	            this.environmentImage = null;
	            this.skyboxImage = null;
	            this.shadowIntensity = DEFAULT_SHADOW_INTENSITY;
	            this.shadowSoftness = DEFAULT_SHADOW_SOFTNESS;
	            this.exposure = DEFAULT_EXPOSURE;
	            this.toneMapping = 'auto';
	            this.skyboxHeight = '0';
	            this[_a] = null;
	            this[_b] = null;
	            this[_c] = null;
	        }
	    }
	    __decorate$7([
	        n$2({
	            type: String,
	            attribute: 'environment-image'
	        })
	    ], EnvironmentModelViewerElement.prototype, "environmentImage", void 0);
	    __decorate$7([
	        n$2({
	            type: String,
	            attribute: 'skybox-image'
	        })
	    ], EnvironmentModelViewerElement.prototype, "skyboxImage", void 0);
	    __decorate$7([
	        n$2({
	            type: Number,
	            attribute: 'shadow-intensity'
	        })
	    ], EnvironmentModelViewerElement.prototype, "shadowIntensity", void 0);
	    __decorate$7([
	        n$2({
	            type: Number,
	            attribute: 'shadow-softness'
	        })
	    ], EnvironmentModelViewerElement.prototype, "shadowSoftness", void 0);
	    __decorate$7([
	        n$2({
	            type: Number
	        })
	    ], EnvironmentModelViewerElement.prototype, "exposure", void 0);
	    __decorate$7([
	        n$2({
	            type: String,
	            attribute: 'tone-mapping'
	        })
	    ], EnvironmentModelViewerElement.prototype, "toneMapping", void 0);
	    __decorate$7([
	        n$2({
	            type: String,
	            attribute: 'skybox-height'
	        })
	    ], EnvironmentModelViewerElement.prototype, "skyboxHeight", void 0);
	    return EnvironmentModelViewerElement;
	};

	var CloseIcon = x$1`
<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 24 24" fill="#000000">
    <!-- NOTE(cdata): This SVG filter is a stop-gap until we can implement
         support for dynamic re-coloring of UI components -->
    <defs>
      <filter id="drop-shadow" x="-100%" y="-100%" width="300%" height="300%">
        <feGaussianBlur in="SourceAlpha" stdDeviation="1"/>
        <feOffset dx="0" dy="0" result="offsetblur"/>
        <feFlood flood-color="#000000"/>
        <feComposite in2="offsetblur" operator="in"/>
        <feMerge>
          <feMergeNode/>
          <feMergeNode in="SourceGraphic"/>
        </feMerge>
      </filter>
    </defs>
    <path filter="url(#drop-shadow)" d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/>
    <path d="M0 0h24v24H0z" fill="none"/>
</svg>`;

	var ControlsPrompt = x$1`
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="25" height="36">
    <defs>
        <path id="A" d="M.001.232h24.997V36H.001z" />
    </defs>
    <g transform="translate(-11 -4)" fill="none" fill-rule="evenodd">
        <path fill-opacity="0" fill="#fff" d="M0 0h44v44H0z" />
        <g transform="translate(11 3)">
            <path d="M8.733 11.165c.04-1.108.766-2.027 1.743-2.307a2.54 2.54 0 0 1 .628-.089c.16 0 .314.017.463.044 1.088.2 1.9 1.092 1.9 2.16v8.88h1.26c2.943-1.39 5-4.45 5-8.025a9.01 9.01 0 0 0-1.9-5.56l-.43-.5c-.765-.838-1.683-1.522-2.712-2-1.057-.49-2.226-.77-3.46-.77s-2.4.278-3.46.77c-1.03.478-1.947 1.162-2.71 2l-.43.5a9.01 9.01 0 0 0-1.9 5.56 9.04 9.04 0 0 0 .094 1.305c.03.21.088.41.13.617l.136.624c.083.286.196.56.305.832l.124.333a8.78 8.78 0 0 0 .509.953l.065.122a8.69 8.69 0 0 0 3.521 3.191l1.11.537v-9.178z" fill-opacity=".5" fill="#e4e4e4" />
            <path d="M22.94 26.218l-2.76 7.74c-.172.485-.676.8-1.253.8H12.24c-1.606 0-3.092-.68-3.98-1.82-1.592-2.048-3.647-3.822-6.11-5.27-.095-.055-.15-.137-.152-.23-.004-.1.046-.196.193-.297.56-.393 1.234-.6 1.926-.6a3.43 3.43 0 0 1 .691.069l4.922.994V10.972c0-.663.615-1.203 1.37-1.203s1.373.54 1.373 1.203v9.882h2.953c.273 0 .533.073.757.21l6.257 3.874c.027.017.045.042.07.06.41.296.586.77.426 1.22M4.1 16.614c-.024-.04-.042-.083-.065-.122a8.69 8.69 0 0 1-.509-.953c-.048-.107-.08-.223-.124-.333l-.305-.832c-.058-.202-.09-.416-.136-.624l-.13-.617a9.03 9.03 0 0 1-.094-1.305c0-2.107.714-4.04 1.9-5.56l.43-.5c.764-.84 1.682-1.523 2.71-2 1.058-.49 2.226-.77 3.46-.77s2.402.28 3.46.77c1.03.477 1.947 1.16 2.712 2l.428.5a9 9 0 0 1 1.901 5.559c0 3.577-2.056 6.636-5 8.026h-1.26v-8.882c0-1.067-.822-1.96-1.9-2.16-.15-.028-.304-.044-.463-.044-.22 0-.427.037-.628.09-.977.28-1.703 1.198-1.743 2.306v9.178l-1.11-.537C6.18 19.098 4.96 18 4.1 16.614M22.97 24.09l-6.256-3.874c-.102-.063-.218-.098-.33-.144 2.683-1.8 4.354-4.855 4.354-8.243 0-.486-.037-.964-.104-1.43a9.97 9.97 0 0 0-1.57-4.128l-.295-.408-.066-.092a10.05 10.05 0 0 0-.949-1.078c-.342-.334-.708-.643-1.094-.922-1.155-.834-2.492-1.412-3.94-1.65l-.732-.088-.748-.03a9.29 9.29 0 0 0-1.482.119c-1.447.238-2.786.816-3.94 1.65a9.33 9.33 0 0 0-.813.686 9.59 9.59 0 0 0-.845.877l-.385.437-.36.5-.288.468-.418.778-.04.09c-.593 1.28-.93 2.71-.93 4.222 0 3.832 2.182 7.342 5.56 8.938l1.437.68v4.946L5 25.64a4.44 4.44 0 0 0-.888-.086c-.017 0-.034.003-.05.003-.252.004-.503.033-.75.08a5.08 5.08 0 0 0-.237.056c-.193.046-.382.107-.568.18-.075.03-.15.057-.225.1-.25.114-.494.244-.723.405a1.31 1.31 0 0 0-.566 1.122 1.28 1.28 0 0 0 .645 1.051C4 29.925 5.96 31.614 7.473 33.563a5.06 5.06 0 0 0 .434.491c1.086 1.082 2.656 1.713 4.326 1.715h6.697c.748-.001 1.43-.333 1.858-.872.142-.18.256-.38.336-.602l2.757-7.74c.094-.26.13-.53.112-.794s-.088-.52-.203-.76a2.19 2.19 0 0 0-.821-.91" fill-opacity=".6" fill="#000" />
            <path d="M22.444 24.94l-6.257-3.874a1.45 1.45 0 0 0-.757-.211h-2.953v-9.88c0-.663-.616-1.203-1.373-1.203s-1.37.54-1.37 1.203v16.643l-4.922-.994a3.44 3.44 0 0 0-.692-.069 3.35 3.35 0 0 0-1.925.598c-.147.102-.198.198-.194.298.004.094.058.176.153.23 2.462 1.448 4.517 3.22 6.11 5.27.887 1.14 2.373 1.82 3.98 1.82h6.686c.577 0 1.08-.326 1.253-.8l2.76-7.74c.16-.448-.017-.923-.426-1.22-.025-.02-.043-.043-.07-.06z" fill="#fff" />
            <g transform="translate(0 .769)">
                <mask id="B" fill="#fff">
                    <use xlink:href="#A" />
                </mask>
                <path d="M23.993 24.992a1.96 1.96 0 0 1-.111.794l-2.758 7.74c-.08.22-.194.423-.336.602-.427.54-1.11.87-1.857.872h-6.698c-1.67-.002-3.24-.633-4.326-1.715-.154-.154-.3-.318-.434-.49C5.96 30.846 4 29.157 1.646 27.773c-.385-.225-.626-.618-.645-1.05a1.31 1.31 0 0 1 .566-1.122 4.56 4.56 0 0 1 .723-.405l.225-.1a4.3 4.3 0 0 1 .568-.18l.237-.056c.248-.046.5-.075.75-.08.018 0 .034-.003.05-.003.303-.001.597.027.89.086l3.722.752V20.68l-1.436-.68c-3.377-1.596-5.56-5.106-5.56-8.938 0-1.51.336-2.94.93-4.222.015-.03.025-.06.04-.09.127-.267.268-.525.418-.778.093-.16.186-.316.288-.468.063-.095.133-.186.2-.277L3.773 5c.118-.155.26-.29.385-.437.266-.3.544-.604.845-.877a9.33 9.33 0 0 1 .813-.686C6.97 2.167 8.31 1.59 9.757 1.35a9.27 9.27 0 0 1 1.481-.119 8.82 8.82 0 0 1 .748.031c.247.02.49.05.733.088 1.448.238 2.786.816 3.94 1.65.387.28.752.588 1.094.922a9.94 9.94 0 0 1 .949 1.078l.066.092c.102.133.203.268.295.408a9.97 9.97 0 0 1 1.571 4.128c.066.467.103.945.103 1.43 0 3.388-1.67 6.453-4.353 8.243.11.046.227.08.33.144l6.256 3.874c.37.23.645.55.82.9.115.24.185.498.203.76m.697-1.195c-.265-.55-.677-1.007-1.194-1.326l-5.323-3.297c2.255-2.037 3.564-4.97 3.564-8.114 0-2.19-.637-4.304-1.84-6.114-.126-.188-.26-.37-.4-.552-.645-.848-1.402-1.6-2.252-2.204C15.472.91 13.393.232 11.238.232A10.21 10.21 0 0 0 5.23 2.19c-.848.614-1.606 1.356-2.253 2.205-.136.18-.272.363-.398.55C1.374 6.756.737 8.87.737 11.06c0 4.218 2.407 8.08 6.133 9.842l.863.41v3.092l-2.525-.51c-.356-.07-.717-.106-1.076-.106a5.45 5.45 0 0 0-3.14.996c-.653.46-1.022 1.202-.99 1.983a2.28 2.28 0 0 0 1.138 1.872c2.24 1.318 4.106 2.923 5.543 4.772 1.26 1.62 3.333 2.59 5.55 2.592h6.698c1.42-.001 2.68-.86 3.134-2.138l2.76-7.74c.272-.757.224-1.584-.134-2.325" fill-opacity=".05" fill="#000" mask="url(#B)" />
            </g>
        </g>
    </g>
</svg>`;

	var ARGlyph = x$1`
<svg version="1.1" id="view_x5F_in_x5F_AR_x5F_icon"
	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="24px" height="24px"
	 viewBox="0 0 24 24" enable-background="new 0 0 24 24" xml:space="preserve">
<rect id="Bounding_Box" x="0" y="0" fill="none" width="24" height="24"/>
<g id="Art_layer">
	<path d="M3,4c0-0.55,0.45-1,1-1h2V1H4C2.35,1,1,2.35,1,4v2h2V4z"/>
	<path d="M20,3c0.55,0,1,0.45,1,1v2h2V4c0-1.65-1.35-3-3-3h-2v2H20z"/>
	<path d="M4,21c-0.55,0-1-0.45-1-1v-2H1v2c0,1.65,1.35,3,3,3h2v-2H4z"/>
	<path d="M20,21c0.55,0,1-0.45,1-1v-2h2v2c0,1.65-1.35,3-3,3h-2v-2H20z"/>
	<g>
		<path d="M18.25,7.6l-5.5-3.18c-0.46-0.27-1.04-0.27-1.5,0L5.75,7.6C5.29,7.87,5,8.36,5,8.9v6.35c0,0.54,0.29,1.03,0.75,1.3
			l5.5,3.18c0.46,0.27,1.04,0.27,1.5,0l5.5-3.18c0.46-0.27,0.75-0.76,0.75-1.3V8.9C19,8.36,18.71,7.87,18.25,7.6z M7,14.96v-4.62
			l4,2.32v4.61L7,14.96z M12,10.93L8,8.61l4-2.31l4,2.31L12,10.93z M13,17.27v-4.61l4-2.32v4.62L13,17.27z"/>
	</g>
</g>
</svg>`;

	const templateResult = x$1`
<style>
:host {
  display: block;
  position: relative;
  contain: strict;
  width: 300px;
  height: 150px;
}

.container {
  position: relative;
  overflow: hidden;
}

.userInput {
  width: 100%;
  height: 100%;
  display: none;
  position: relative;
  outline-offset: -1px;
  outline-width: 1px;
}

canvas {
  position: absolute;
  display: none;
  pointer-events: none;
  /* NOTE(cdata): Chrome 76 and below apparently have a bug
   * that causes our canvas not to display pixels unless it is
   * on its own render layer
   * @see https://github.com/google/model-viewer/pull/755#issuecomment-536597893
   */
  transform: translateZ(0);
}

.show {
  display: block;
}

/* Adapted from HTML5 Boilerplate
 *
 * @see https://github.com/h5bp/html5-boilerplate/blob/ceb4620c78fc82e13534fc44202a3f168754873f/dist/css/main.css#L122-L133 */
.screen-reader-only {
  border: 0;
  left: 0;
  top: 0;
  clip: rect(0, 0, 0, 0);
  height: 1px;
  margin: -1px;
  overflow: hidden;
  padding: 0;
  position: absolute;
  white-space: nowrap;
  width: 1px;
  pointer-events: none;
}

.slot {
  position: absolute;
  pointer-events: none;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
}

.slot > * {
  pointer-events: initial;
}

.annotation-wrapper ::slotted(*) {
  opacity: var(--max-hotspot-opacity, 1);
  transition: opacity 0.3s;
}

.pointer-tumbling .annotation-wrapper ::slotted(*) {
  pointer-events: none;
}

.annotation-wrapper ::slotted(*) {
  pointer-events: initial;
}

.annotation-wrapper.hide ::slotted(*) {
  opacity: var(--min-hotspot-opacity, 0.25);
}

.slot.poster {
  display: none;
  background-color: inherit;
}

.slot.poster.show {
  display: inherit;
}

.slot.poster > * {
  pointer-events: initial;
}

.slot.poster:not(.show) > * {
  pointer-events: none;
}

#default-poster {
  width: 100%;
  height: 100%;
  /* The default poster is a <button> so we need to set display
   * to prevent it from being affected by text-align: */
  display: block;
  position: absolute;
  border: none;
  padding: 0;
  background-size: contain;
  background-repeat: no-repeat;
  background-position: center;
  background-color: #fff0;
}

#default-progress-bar {
  display: block;
  position: relative;
  width: 100%;
  height: 100%;
  pointer-events: none;
  overflow: hidden;
}

#default-progress-bar > .bar {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: var(--progress-bar-height, 5px);
  background-color: var(--progress-bar-color, rgba(0, 0, 0, 0.4));
  transition: transform 0.09s;
  transform-origin: top left;
  transform: scaleX(0);
  overflow: hidden;
}

#default-progress-bar > .bar.hide {
  transition: opacity 0.3s 1s;
  opacity: 0;
}

.centered {
  align-items: center;
  justify-content: center;
}

.cover {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  pointer-events: none;
}

.slot.interaction-prompt {
  display: var(--interaction-prompt-display, flex);
  overflow: hidden;
  opacity: 0;
  will-change: opacity;
  transition: opacity 0.3s;
}

.slot.interaction-prompt.visible {
  opacity: 1;
}

.animated-container {
  will-change: transform, opacity;
  opacity: 0;
  transition: opacity 0.3s;
}

.slot.interaction-prompt > * {
  pointer-events: none;
}

.slot.ar-button {
  -moz-user-select: none;
  -webkit-tap-highlight-color: transparent;
  user-select: none;

  display: var(--ar-button-display, block);
}

.slot.ar-button:not(.enabled) {
  display: none;
}

.fab {
  display: flex;
  align-items: center;
  justify-content: center;
  box-sizing: border-box;
  width: 40px;
  height: 40px;
  cursor: pointer;
  background-color: #fff;
  box-shadow: 0px 0px 4px rgba(0, 0, 0, 0.15);
  border-radius: 100px;
}

.fab > * {
  opacity: 0.87;
}

#default-ar-button {
  position: absolute;
  bottom: 16px;
  right: 16px;
  transform: scale(var(--ar-button-scale, 1));
  transform-origin: bottom right;
}

.slot.pan-target {
  display: block;
  position: absolute;
  width: 0;
  height: 0;
  left: 50%;
  top: 50%;
  transform: translate3d(-50%, -50%, 0);
  background-color: transparent;
  opacity: 0;
  transition: opacity 0.3s;
}

#default-pan-target {
  width: 6px;
  height: 6px;
  border-radius: 6px;
  border: 1px solid white;
  box-shadow: 0px 0px 2px 1px rgba(0, 0, 0, 0.8);
}

.slot.default {
  pointer-events: none;
}

.slot.progress-bar {
  pointer-events: none;
}

.slot.exit-webxr-ar-button {
  pointer-events: none;
}

.slot.exit-webxr-ar-button:not(.enabled) {
  display: none;
}

#default-exit-webxr-ar-button {
  display: flex;
  align-items: center;
  justify-content: center;
  position: absolute;
  top: env(safe-area-inset-top, 16px);
  right: 16px;
  width: 40px;
  height: 40px;
  box-sizing: border-box;
}

#default-exit-webxr-ar-button > svg {
  fill: #fff;
}
</style>
<div class="container">
  <div class="userInput" tabindex="0" role="img"
      aria-label="3D model">
      <div class="slot canvas">
        <slot name="canvas">
          <canvas></canvas>
        </slot>
      </div>

  </div>

  <!-- NOTE(cdata): We need to wrap slots because browsers without ShadowDOM
        will have their <slot> elements removed by ShadyCSS -->
  <div class="slot poster">
    <slot name="poster">
      <button type="button" id="default-poster" aria-hidden="true" aria-label="Loading 3D model"></button>
    </slot>
  </div>

  <div class="slot ar-button">
    <slot name="ar-button">
      <a id="default-ar-button" part="default-ar-button" class="fab"
          tabindex="2"
          role="button"
          href="javascript:void(0);"
          aria-label="View in your space">
        ${ARGlyph}
      </a>
    </slot>
  </div>

  <div class="slot pan-target">
    <slot name="pan-target">
      <div id="default-pan-target">
      </div>
    </slot>
  </div>

  <div class="slot interaction-prompt cover centered">
    <div id="prompt" class="animated-container">
      <slot name="interaction-prompt" aria-hidden="true">
        ${ControlsPrompt}
      </slot>
    </div>
  </div>

  <div id="finger0" class="animated-container cover">
    <slot name="finger0" aria-hidden="true">
    </slot>
  </div>
  <div id="finger1" class="animated-container cover">
    <slot name="finger1" aria-hidden="true">
    </slot>
  </div>

  <div class="slot default">
    <slot></slot>

    <div class="slot progress-bar">
      <slot name="progress-bar">
        <div id="default-progress-bar" aria-hidden="true">
          <div class="bar" part="default-progress-bar"></div>
        </div>
      </slot>
    </div>

    <div class="slot exit-webxr-ar-button">
      <slot name="exit-webxr-ar-button">
        <a id="default-exit-webxr-ar-button" part="default-exit-webxr-ar-button"
            tabindex="3"
            aria-label="Exit AR"
            aria-hidden="true">
          ${CloseIcon}
        </a>
      </slot>
    </div>
  </div>
</div>
<div class="screen-reader-only" role="region" aria-label="Live announcements">
  <span id="status" role="status"></span>
</div>`;
	const makeTemplate = (shadowRoot)=>{
	    B$1(templateResult, shadowRoot);
	};

	// This file is part of meshoptimizer library and is distributed under the terms of MIT License.
	// Copyright (C) 2016-2022, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
	var MeshoptDecoder = function() {
	    // Built with clang version 14.0.4
	    // Built from meshoptimizer 0.18
	    var wasm_base = "b9H79Tebbbe8Fv9Gbb9Gvuuuuueu9Giuuub9Geueu9Giuuueuikqbeeedddillviebeoweuec:q;iekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbeY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVbdE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbiL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtblK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbol79IV9Rbrq:P8Yqdbk;3sezu8Jjjjjbcj;eb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Radz1jjjbhwcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhDcbhqinaqae9pmeaDaeaq9RaqaDfae6Egkcsfgocl4cifcd4hxdndndndnaoc9WGgmTmbcbhPcehsawcjdfhzalhHinaraH9Rax6midnaraHaxfgl9RcK6mbczhoinawcj;cbfaogifgoc9WfhOdndndndndnaHaic9WfgAco4fRbbaAci4coG4ciGPlbedibkaO9cb83ibaOcwf9cb83ibxikaOalRblalRbbgAco4gCaCciSgCE86bbaocGfalclfaCfgORbbaAcl4ciGgCaCciSgCE86bbaocVfaOaCfgORbbaAcd4ciGgCaCciSgCE86bbaoc7faOaCfgORbbaAciGgAaAciSgAE86bbaoctfaOaAfgARbbalRbegOco4gCaCciSgCE86bbaoc91faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc4faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc93faAaCfgARbbaOciGgOaOciSgOE86bbaoc94faAaOfgARbbalRbdgOco4gCaCciSgCE86bbaoc95faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc96faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc97faAaCfgARbbaOciGgOaOciSgOE86bbaoc98faAaOfgORbbalRbiglco4gAaAciSgAE86bbaoc99faOaAfgORbbalcl4ciGgAaAciSgAE86bbaoc9:faOaAfgORbbalcd4ciGgAaAciSgAE86bbaocufaOaAfgoRbbalciGglalciSglE86bbaoalfhlxdkaOalRbwalRbbgAcl4gCaCcsSgCE86bbaocGfalcwfaCfgORbbaAcsGgAaAcsSgAE86bbaocVfaOaAfgORbbalRbegAcl4gCaCcsSgCE86bbaoc7faOaCfgORbbaAcsGgAaAcsSgAE86bbaoctfaOaAfgORbbalRbdgAcl4gCaCcsSgCE86bbaoc91faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc4faOaAfgORbbalRbigAcl4gCaCcsSgCE86bbaoc93faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc94faOaAfgORbbalRblgAcl4gCaCcsSgCE86bbaoc95faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc96faOaAfgORbbalRbvgAcl4gCaCcsSgCE86bbaoc97faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc98faOaAfgORbbalRbogAcl4gCaCcsSgCE86bbaoc99faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc9:faOaAfgORbbalRbrglcl4gAaAcsSgAE86bbaocufaOaAfgoRbbalcsGglalcsSglE86bbaoalfhlxekaOal8Pbb83bbaOcwfalcwf8Pbb83bbalczfhlkdnaiam9pmbaiczfhoaral9RcL0mekkaiam6mialTmidnakTmbawaPfRbbhOcbhoazhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkkazcefhzaPcefgPad6hsalhHaPad9hmexvkkcbhlasceGmdxikalaxad2fhCdnakTmbcbhHcehsawcjdfhminaral9Rax6mialTmdalaxfhlawaHfRbbhOcbhoamhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkamcefhmaHcefgHad6hsaHad9hmbkaChlxikcbhocehsinaral9Rax6mdalTmealaxfhlaocefgoad6hsadao9hmbkaChlxdkcbhlasceGTmekc9:hoxikabaqad2fawcjdfakad2z1jjjb8Aawawcjdfakcufad2fadz1jjjb8Aakaqfhqalmbkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;ebf8Kjjjjbaok;yzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecjez:jjjjb8AavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:Lvoeue99dud99eud99dndnadcl9hmbaeTmeindndnabcdfgd8Sbb:Yab8Sbbgi:Ygl:l:tabcefgv8Sbbgo:Ygr:l:tgwJbb;:9cawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai86bbdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad86bbdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad86bbabclfhbaecufgembxdkkaeTmbindndnabclfgd8Ueb:Yab8Uebgi:Ygl:l:tabcdfgv8Uebgo:Ygr:l:tgwJb;:FSawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai87ebdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad87ebdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad87ebabcwfhbaecufgembkkk;siliui99iue99dnaeTmbcbhiabhlindndnJ;Zl81Zalcof8UebgvciV:Y:vgoal8Ueb:YNgrJb;:FSNJbbbZJbbb:;arJbbbb9GEMgw:lJbbb9p9DTmbaw:OhDxekcjjjj94hDkalclf8Uebhqalcdf8UebhkabavcefciGaiVcetfaD87ebdndnaoak:YNgwJb;:FSNJbbbZJbbb:;awJbbbb9GEMgx:lJbbb9p9DTmbax:Ohkxekcjjjj94hkkabavcdfciGaiVcetfak87ebdndnaoaq:YNgoJb;:FSNJbbbZJbbb:;aoJbbbb9GEMgx:lJbbb9p9DTmbax:Ohqxekcjjjj94hqkabavcufciGaiVcetfaq87ebdndnJbbjZararN:tawawN:taoaoN:tgrJbbbbarJbbbb9GE:rJb;:FSNJbbbZMgr:lJbbb9p9DTmbar:Ohqxekcjjjj94hqkabavciGaiVcetfaq87ebalcwfhlaiclfhiaecufgembkkk9mbdnadcd4ae2geTmbinababydbgdcwtcw91:Yadce91cjjj;8ifcjjj98G::NUdbabclfhbaecufgembkkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaiczfhiaeczfheadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabkkkebcjwklz9Kbb";
	    var wasm_simd = "b9H79TebbbeKl9Gbb9Gvuuuuueu9Giuuub9Geueuikqbbebeedddilve9Weeeviebeoweuec:q;Aekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbdY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVblE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtboK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbrL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbwl79IV9RbDq;t9tqlbzik9:evu8Jjjjjbcz9Rhbcbheincbhdcbhiinabcwfadfaicjuaead4ceGglE86bbaialfhiadcefgdcw9hmbkaec:q:yjjbfai86bbaecitc:q1jjbfab8Piw83ibaecefgecjd9hmbkk;h8JlHud97euo978Jjjjjbcj;kb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Rad;8qbbcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhwcbhDinaDae9pmeawaeaD9RaDawfae6Egqcsfgoc9WGgkci2hxakcethmaocl4cifcd4hPabaDad2fhscbhzdnincehHalhOcbhAdninaraO9RaP6miavcj;cbfaAak2fhCaOaPfhlcbhidnakc;ab6mbaral9Rc;Gb6mbcbhoinaCaofhidndndndndnaOaoco4fRbbgXciGPlbedibkaipxbbbbbbbbbbbbbbbbpklbxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklbalczfhlkdndndndndnaXcd4ciGPlbedibkaipxbbbbbbbbbbbbbbbbpklzxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklzalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklzalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklzalczfhlkdndndndndnaXcl4ciGPlbedibkaipxbbbbbbbbbbbbbbbbpklaxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklaalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklaalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaialpbbbpklaalczfhlkdndndndndnaXco4Plbedibkaipxbbbbbbbbbbbbbbbbpkl8WxikaialpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibaXc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spkl8WalclfaYpQbfaXc:q:yjjbfRbbfhlxdkaialpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibaXc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgXcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spkl8WalcwfaYpQbfaXc:q:yjjbfRbbfhlxekaialpbbbpkl8Walczfhlkaoc;abfhiaocjefak0meaihoaral9Rc;Fb0mbkkdndnaiak9pmbaici4hoinaral9RcK6mdaCaifhXdndndndndnaOaico4fRbbaocoG4ciGPlbedibkaXpxbbbbbbbbbbbbbbbbpklbxikaXalpbblalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLgQcdp:meaQpmbzeHdOiAlCvXoQrLpxiiiiiiiiiiiiiiiip9ogLpxiiiiiiiiiiiiiiiip8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalclfaYpQbfaKc:q:yjjbfRbbfhlxdkaXalpbbwalpbbbgQclp:meaQpmbzeHdOiAlCvXoQrLpxssssssssssssssssp9ogLpxssssssssssssssssp8JgQp5b9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibaKc:q:yjjbfpbbbgYaYpmbbbbbbbbbbbbbbbbaQp5e9cjF;8;4;W;G;ab9:9cU1:NgKcitc:q1jjbfpbibp9UpmbedilvorzHOACXQLpPaLaQp9spklbalcwfaYpQbfaKc:q:yjjbfRbbfhlxekaXalpbbbpklbalczfhlkaocdfhoaiczfgiak6mbkkalTmbaAci6hHalhOaAcefgohAaoclSmdxekkcbhlaHceGmdkdnakTmbavcjdfazfhiavazfpbdbhYcbhXinaiavcj;cbfaXfgopblbgLcep9TaLpxeeeeeeeeeeeeeeeegQp9op9Hp9rgLaoakfpblbg8Acep9Ta8AaQp9op9Hp9rg8ApmbzeHdOiAlCvXoQrLgEaoamfpblbg3cep9Ta3aQp9op9Hp9rg3aoaxfpblbg5cep9Ta5aQp9op9Hp9rg5pmbzeHdOiAlCvXoQrLg8EpmbezHdiOAlvCXorQLgQaQpmbedibedibedibediaYp9UgYp9AdbbaiadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaEa8EpmwDKYqk8AExm35Ps8E8FgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaLa8ApmwKDYq8AkEx3m5P8Es8FgLa3a5pmwKDYq8AkEx3m5P8Es8Fg8ApmbezHdiOAlvCXorQLgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfgoaYaLa8ApmwDKYqk8AExm35Ps8E8FgQaQpmbedibedibedibedip9UgYp9AdbbaoadfgoaYaQaQpmlvorlvorlvorlvorp9UgYp9AdbbaoadfgoaYaQaQpmwDqkwDqkwDqkwDqkp9UgYp9AdbbaoadfgoaYaQaQpmxmPsxmPsxmPsxmPsp9UgYp9AdbbaoadfhiaXczfgXak6mbkkazclfgzad6mbkasavcjdfaqad2;8qbbavavcjdfaqcufad2fad;8qbbaqaDfhDc9:hoalmexikkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;kbf8Kjjjjbaokwbz:bjjjbk;uzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecje;8kbavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:EPliuo97eue978Jjjjjbca9Rhidndnadcl9hmbdnaec98GglTmbcbhvabhdinadadpbbbgocKp:RecKp:Sep;6egraocwp:RecKp:Sep;6earp;Geaoczp:RecKp:Sep;6egwp;Gep;Kep;LegDpxbbbbbbbbbbbbbbbbp:2egqarpxbbbjbbbjbbbjbbbjgkp9op9rp;Kegrpxbb;:9cbb;:9cbb;:9cbb;:9cararp;MeaDaDp;Meawaqawakp9op9rp;Kegrarp;Mep;Kep;Kep;Jep;Negwp;Mepxbbn0bbn0bbn0bbn0gqp;KepxFbbbFbbbFbbbFbbbp9oaopxbbbFbbbFbbbFbbbFp9op9qarawp;Meaqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaDawp;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpkbbadczfhdavclfgval6mbkkalae9pmeaiaeciGgvcdtgdVcbczad9R;8kbaiabalcdtfglad;8qbbdnavTmbaiaipblbgocKp:RecKp:Sep;6egraocwp:RecKp:Sep;6earp;Geaoczp:RecKp:Sep;6egwp;Gep;Kep;LegDpxbbbbbbbbbbbbbbbbp:2egqarpxbbbjbbbjbbbjbbbjgkp9op9rp;Kegrpxbb;:9cbb;:9cbb;:9cbb;:9cararp;MeaDaDp;Meawaqawakp9op9rp;Kegrarp;Mep;Kep;Kep;Jep;Negwp;Mepxbbn0bbn0bbn0bbn0gqp;KepxFbbbFbbbFbbbFbbbp9oaopxbbbFbbbFbbbFbbbFp9op9qarawp;Meaqp;Kecwp:RepxbFbbbFbbbFbbbFbbp9op9qaDawp;Meaqp;Keczp:RepxbbFbbbFbbbFbbbFbp9op9qpklbkalaiad;8qbbskdnaec98GgxTmbcbhvabhdinadczfglalpbbbgopxbbbbbbFFbbbbbbFFgkp9oadpbbbgDaopmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eaDaopmbediwDqkzHOAKY8AEgoczp:Sep;6egrp;Geaoczp:Reczp:Sep;6egwp;Gep;Kep;Legopxb;:FSb;:FSb;:FSb;:FSawaopxbbbbbbbbbbbbbbbbp:2egqawpxbbbjbbbjbbbjbbbjgmp9op9rp;Kegwawp;Meaoaop;Mearaqaramp9op9rp;Kegoaop;Mep;Kep;Kep;Jep;Negrp;Mepxbbn0bbn0bbn0bbn0gqp;Keczp:Reawarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9op9qgwaoarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9ogopmwDKYqk8AExm35Ps8E8Fp9qpkbbadaDakp9oawaopmbezHdiOAlvCXorQLp9qpkbbadcafhdavclfgvax6mbkkaxae9pmbaiaeciGgvcitgdfcbcaad9R;8kbaiabaxcitfglad;8qbbdnavTmbaiaipblzgopxbbbbbbFFbbbbbbFFgkp9oaipblbgDaopmlvorxmPsCXQL358E8FpxFubbFubbFubbFubbp9op;6eaDaopmbediwDqkzHOAKY8AEgoczp:Sep;6egrp;Geaoczp:Reczp:Sep;6egwp;Gep;Kep;Legopxb;:FSb;:FSb;:FSb;:FSawaopxbbbbbbbbbbbbbbbbp:2egqawpxbbbjbbbjbbbjbbbjgmp9op9rp;Kegwawp;Meaoaop;Mearaqaramp9op9rp;Kegoaop;Mep;Kep;Kep;Jep;Negrp;Mepxbbn0bbn0bbn0bbn0gqp;Keczp:Reawarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9op9qgwaoarp;Meaqp;KepxFFbbFFbbFFbbFFbbp9ogopmwDKYqk8AExm35Ps8E8Fp9qpklzaiaDakp9oawaopmbezHdiOAlvCXorQLp9qpklbkalaiad;8qbbkk;4wllue97euv978Jjjjjbc8W9Rhidnaec98GglTmbcbhvabhoinaiaopbbbgraoczfgwpbbbgDpmlvorxmPsCXQL358E8Fgqczp:Segkclp:RepklbaopxbbjZbbjZbbjZbbjZpx;Zl81Z;Zl81Z;Zl81Z;Zl81Zakpxibbbibbbibbbibbbp9qp;6ep;NegkaraDpmbediwDqkzHOAKY8AEgrczp:Reczp:Sep;6ep;MegDaDp;Meakarczp:Sep;6ep;Megxaxp;Meakaqczp:Reczp:Sep;6ep;Megqaqp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jepxb;:FSb;:FSb;:FSb;:FSgkp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbgmp9oaxakp;Mearp;Keczp:Rep9qgxaqakp;Mearp;Keczp:ReaDakp;Mearp;Keamp9op9qgkpmbezHdiOAlvCXorQLgrp5baipblbpEb:T:j83ibaocwfarp5eaipblbpEe:T:j83ibawaxakpmwDKYqk8AExm35Ps8E8Fgkp5baipblbpEd:T:j83ibaocKfakp5eaipblbpEi:T:j83ibaocafhoavclfgval6mbkkdnalae9pmbaiaeciGgvcitgofcbcaao9R;8kbaiabalcitfgwao;8qbbdnavTmbaiaipblbgraipblzgDpmlvorxmPsCXQL358E8Fgqczp:Segkclp:RepklaaipxbbjZbbjZbbjZbbjZpx;Zl81Z;Zl81Z;Zl81Z;Zl81Zakpxibbbibbbibbbibbbp9qp;6ep;NegkaraDpmbediwDqkzHOAKY8AEgrczp:Reczp:Sep;6ep;MegDaDp;Meakarczp:Sep;6ep;Megxaxp;Meakaqczp:Reczp:Sep;6ep;Megqaqp;Mep;Kep;Kep;Lepxbbbbbbbbbbbbbbbbp:4ep;Jepxb;:FSb;:FSb;:FSb;:FSgkp;Mepxbbn0bbn0bbn0bbn0grp;KepxFFbbFFbbFFbbFFbbgmp9oaxakp;Mearp;Keczp:Rep9qgxaqakp;Mearp;Keczp:ReaDakp;Mearp;Keamp9op9qgkpmbezHdiOAlvCXorQLgrp5baipblapEb:T:j83ibaiarp5eaipblapEe:T:j83iwaiaxakpmwDKYqk8AExm35Ps8E8Fgkp5baipblapEd:T:j83izaiakp5eaipblapEi:T:j83iKkawaiao;8qbbkk:Pddiue978Jjjjjbc;ab9Rhidnadcd4ae2glc98GgvTmbcbhdabheinaeaepbbbgocwp:Recwp:Sep;6eaocep:SepxbbjZbbjZbbjZbbjZp:UepxbbjFbbjFbbjFbbjFp9op;Mepkbbaeczfheadclfgdav6mbkkdnaval9pmbaialciGgdcdtgeVcbc;abae9R;8kbaiabavcdtfgvae;8qbbdnadTmbaiaipblbgocwp:Recwp:Sep;6eaocep:SepxbbjZbbjZbbjZbbjZp:UepxbbjFbbjFbbjFbbjFp9op;Mepklbkavaiae;8qbbkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaikkkebcjwklz9Tbb";
	    var detector = new Uint8Array([
	        0,
	        97,
	        115,
	        109,
	        1,
	        0,
	        0,
	        0,
	        1,
	        4,
	        1,
	        96,
	        0,
	        0,
	        3,
	        3,
	        2,
	        0,
	        0,
	        5,
	        3,
	        1,
	        0,
	        1,
	        12,
	        1,
	        0,
	        10,
	        22,
	        2,
	        12,
	        0,
	        65,
	        0,
	        65,
	        0,
	        65,
	        0,
	        252,
	        10,
	        0,
	        0,
	        11,
	        7,
	        0,
	        65,
	        0,
	        253,
	        15,
	        26,
	        11
	    ]);
	    var wasmpack = new Uint8Array([
	        32,
	        0,
	        65,
	        2,
	        1,
	        106,
	        34,
	        33,
	        3,
	        128,
	        11,
	        4,
	        13,
	        64,
	        6,
	        253,
	        10,
	        7,
	        15,
	        116,
	        127,
	        5,
	        8,
	        12,
	        40,
	        16,
	        19,
	        54,
	        20,
	        9,
	        27,
	        255,
	        113,
	        17,
	        42,
	        67,
	        24,
	        23,
	        146,
	        148,
	        18,
	        14,
	        22,
	        45,
	        70,
	        69,
	        56,
	        114,
	        101,
	        21,
	        25,
	        63,
	        75,
	        136,
	        108,
	        28,
	        118,
	        29,
	        73,
	        115
	    ]);
	    if (typeof WebAssembly !== 'object') {
	        return {
	            supported: false
	        };
	    }
	    var wasm = WebAssembly.validate(detector) ? wasm_simd : wasm_base;
	    var instance;
	    var ready = WebAssembly.instantiate(unpack(wasm), {}).then(function(result) {
	        instance = result.instance;
	        instance.exports.__wasm_call_ctors();
	    });
	    function unpack(data) {
	        var result = new Uint8Array(data.length);
	        for(var i = 0; i < data.length; ++i){
	            var ch = data.charCodeAt(i);
	            result[i] = ch > 96 ? ch - 97 : ch > 64 ? ch - 39 : ch + 4;
	        }
	        var write = 0;
	        for(var i = 0; i < data.length; ++i){
	            result[write++] = result[i] < 60 ? wasmpack[result[i]] : (result[i] - 60) * 64 + result[++i];
	        }
	        return result.buffer.slice(0, write);
	    }
	    function decode(fun, target, count, size, source, filter) {
	        var sbrk = instance.exports.sbrk;
	        var count4 = count + 3 & -4;
	        var tp = sbrk(count4 * size);
	        var sp = sbrk(source.length);
	        var heap = new Uint8Array(instance.exports.memory.buffer);
	        heap.set(source, sp);
	        var res = fun(tp, count, size, sp, source.length);
	        if (res == 0 && filter) {
	            filter(tp, count4, size);
	        }
	        target.set(heap.subarray(tp, tp + count * size));
	        sbrk(tp - sbrk(0));
	        if (res != 0) {
	            throw new Error("Malformed buffer data: " + res);
	        }
	    }
	    var filters = {
	        NONE: "",
	        OCTAHEDRAL: "meshopt_decodeFilterOct",
	        QUATERNION: "meshopt_decodeFilterQuat",
	        EXPONENTIAL: "meshopt_decodeFilterExp"
	    };
	    var decoders = {
	        ATTRIBUTES: "meshopt_decodeVertexBuffer",
	        TRIANGLES: "meshopt_decodeIndexBuffer",
	        INDICES: "meshopt_decodeIndexSequence"
	    };
	    var workers = [];
	    var requestId = 0;
	    function createWorker(url) {
	        var worker = {
	            object: new Worker(url),
	            pending: 0,
	            requests: {}
	        };
	        worker.object.onmessage = function(event) {
	            var data = event.data;
	            worker.pending -= data.count;
	            worker.requests[data.id][data.action](data.value);
	            delete worker.requests[data.id];
	        };
	        return worker;
	    }
	    function initWorkers(count) {
	        var source = "var instance; var ready = WebAssembly.instantiate(new Uint8Array([" + new Uint8Array(unpack(wasm)) + "]), {})" + ".then(function(result) { instance = result.instance; instance.exports.__wasm_call_ctors(); });" + "self.onmessage = workerProcess;" + decode.toString() + workerProcess.toString();
	        var blob = new Blob([
	            source
	        ], {
	            type: 'text/javascript'
	        });
	        var url = URL.createObjectURL(blob);
	        for(var i = 0; i < count; ++i){
	            workers[i] = createWorker(url);
	        }
	        URL.revokeObjectURL(url);
	    }
	    function decodeWorker(count, size, source, mode, filter) {
	        var worker = workers[0];
	        for(var i = 1; i < workers.length; ++i){
	            if (workers[i].pending < worker.pending) {
	                worker = workers[i];
	            }
	        }
	        return new Promise(function(resolve, reject) {
	            var data = new Uint8Array(source);
	            var id = requestId++;
	            worker.pending += count;
	            worker.requests[id] = {
	                resolve: resolve,
	                reject: reject
	            };
	            worker.object.postMessage({
	                id: id,
	                count: count,
	                size: size,
	                source: data,
	                mode: mode,
	                filter: filter
	            }, [
	                data.buffer
	            ]);
	        });
	    }
	    function workerProcess(event) {
	        ready.then(function() {
	            var data = event.data;
	            try {
	                var target = new Uint8Array(data.count * data.size);
	                decode(instance.exports[data.mode], target, data.count, data.size, data.source, instance.exports[data.filter]);
	                self.postMessage({
	                    id: data.id,
	                    count: data.count,
	                    action: "resolve",
	                    value: target
	                }, [
	                    target.buffer
	                ]);
	            } catch (error) {
	                self.postMessage({
	                    id: data.id,
	                    count: data.count,
	                    action: "reject",
	                    value: error
	                });
	            }
	        });
	    }
	    return {
	        ready: ready,
	        supported: true,
	        useWorkers: function(count) {
	            initWorkers(count);
	        },
	        decodeVertexBuffer: function(target, count, size, source, filter) {
	            decode(instance.exports.meshopt_decodeVertexBuffer, target, count, size, source, instance.exports[filters[filter]]);
	        },
	        decodeIndexBuffer: function(target, count, size, source) {
	            decode(instance.exports.meshopt_decodeIndexBuffer, target, count, size, source);
	        },
	        decodeIndexSequence: function(target, count, size, source) {
	            decode(instance.exports.meshopt_decodeIndexSequence, target, count, size, source);
	        },
	        decodeGltfBuffer: function(target, count, size, source, mode, filter) {
	            decode(instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]);
	        },
	        decodeGltfBufferAsync: function(count, size, source, mode, filter) {
	            if (workers.length > 0) {
	                return decodeWorker(count, size, source, decoders[mode], filters[filter]);
	            }
	            return ready.then(function() {
	                var target = new Uint8Array(count * size);
	                decode(instance.exports[decoders[mode]], target, count, size, source, instance.exports[filters[filter]]);
	                return target;
	            });
	        }
	    };
	}();

	const _taskCache$1 = new WeakMap();
	class DRACOLoader extends Loader {
	    setDecoderPath(path) {
	        this.decoderPath = path;
	        return this;
	    }
	    setDecoderConfig(config) {
	        this.decoderConfig = config;
	        return this;
	    }
	    setWorkerLimit(workerLimit) {
	        this.workerLimit = workerLimit;
	        return this;
	    }
	    load(url, onLoad, onProgress, onError) {
	        const loader = new FileLoader(this.manager);
	        loader.setPath(this.path);
	        loader.setResponseType('arraybuffer');
	        loader.setRequestHeader(this.requestHeader);
	        loader.setWithCredentials(this.withCredentials);
	        loader.load(url, (buffer)=>{
	            this.parse(buffer, onLoad, onError);
	        }, onProgress, onError);
	    }
	    parse(buffer, onLoad, onError = ()=>{}) {
	        this.decodeDracoFile(buffer, onLoad, null, null, SRGBColorSpace, onError).catch(onError);
	    }
	    decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertexColorSpace = LinearSRGBColorSpace, onError = ()=>{}) {
	        const taskConfig = {
	            attributeIDs: attributeIDs || this.defaultAttributeIDs,
	            attributeTypes: attributeTypes || this.defaultAttributeTypes,
	            useUniqueIDs: !!attributeIDs,
	            vertexColorSpace: vertexColorSpace
	        };
	        return this.decodeGeometry(buffer, taskConfig).then(callback).catch(onError);
	    }
	    decodeGeometry(buffer, taskConfig) {
	        const taskKey = JSON.stringify(taskConfig);
	        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
	        // again from this thread.
	        if (_taskCache$1.has(buffer)) {
	            const cachedTask = _taskCache$1.get(buffer);
	            if (cachedTask.key === taskKey) {
	                return cachedTask.promise;
	            } else if (buffer.byteLength === 0) {
	                // Technically, it would be possible to wait for the previous task to complete,
	                // transfer the buffer back, and decode again with the second configuration. That
	                // is complex, and I don't know of any reason to decode a Draco buffer twice in
	                // different ways, so this is left unimplemented.
	                throw new Error('THREE.DRACOLoader: Unable to re-decode a buffer with different ' + 'settings. Buffer has already been transferred.');
	            }
	        }
	        //
	        let worker;
	        const taskID = this.workerNextTaskID++;
	        const taskCost = buffer.byteLength;
	        // Obtain a worker and assign a task, and construct a geometry instance
	        // when the task completes.
	        const geometryPending = this._getWorker(taskID, taskCost).then((_worker)=>{
	            worker = _worker;
	            return new Promise((resolve, reject)=>{
	                worker._callbacks[taskID] = {
	                    resolve,
	                    reject
	                };
	                worker.postMessage({
	                    type: 'decode',
	                    id: taskID,
	                    taskConfig,
	                    buffer
	                }, [
	                    buffer
	                ]);
	            // this.debug();
	            });
	        }).then((message)=>this._createGeometry(message.geometry));
	        // Remove task from the task list.
	        // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
	        geometryPending.catch(()=>true).then(()=>{
	            if (worker && taskID) {
	                this._releaseTask(worker, taskID);
	            // this.debug();
	            }
	        });
	        // Cache the task result.
	        _taskCache$1.set(buffer, {
	            key: taskKey,
	            promise: geometryPending
	        });
	        return geometryPending;
	    }
	    _createGeometry(geometryData) {
	        const geometry = new BufferGeometry();
	        if (geometryData.index) {
	            geometry.setIndex(new BufferAttribute(geometryData.index.array, 1));
	        }
	        for(let i = 0; i < geometryData.attributes.length; i++){
	            const result = geometryData.attributes[i];
	            const name = result.name;
	            const array = result.array;
	            const itemSize = result.itemSize;
	            const attribute = new BufferAttribute(array, itemSize);
	            if (name === 'color') {
	                this._assignVertexColorSpace(attribute, result.vertexColorSpace);
	                attribute.normalized = array instanceof Float32Array === false;
	            }
	            geometry.setAttribute(name, attribute);
	        }
	        return geometry;
	    }
	    _assignVertexColorSpace(attribute, inputColorSpace) {
	        // While .drc files do not specify colorspace, the only 'official' tooling
	        // is PLY and OBJ converters, which use sRGB. We'll assume sRGB when a .drc
	        // file is passed into .load() or .parse(). GLTFLoader uses internal APIs
	        // to decode geometry, and vertex colors are already Linear-sRGB in there.
	        if (inputColorSpace !== SRGBColorSpace) return;
	        const _color = new Color();
	        for(let i = 0, il = attribute.count; i < il; i++){
	            _color.fromBufferAttribute(attribute, i);
	            ColorManagement.toWorkingColorSpace(_color, SRGBColorSpace);
	            attribute.setXYZ(i, _color.r, _color.g, _color.b);
	        }
	    }
	    _loadLibrary(url, responseType) {
	        const loader = new FileLoader(this.manager);
	        loader.setPath(this.decoderPath);
	        loader.setResponseType(responseType);
	        loader.setWithCredentials(this.withCredentials);
	        return new Promise((resolve, reject)=>{
	            loader.load(url, resolve, undefined, reject);
	        });
	    }
	    preload() {
	        this._initDecoder();
	        return this;
	    }
	    _initDecoder() {
	        if (this.decoderPending) return this.decoderPending;
	        const useJS = typeof WebAssembly !== 'object' || this.decoderConfig.type === 'js';
	        const librariesPending = [];
	        if (useJS) {
	            librariesPending.push(this._loadLibrary('draco_decoder.js', 'text'));
	        } else {
	            librariesPending.push(this._loadLibrary('draco_wasm_wrapper.js', 'text'));
	            librariesPending.push(this._loadLibrary('draco_decoder.wasm', 'arraybuffer'));
	        }
	        this.decoderPending = Promise.all(librariesPending).then((libraries)=>{
	            const jsContent = libraries[0];
	            if (!useJS) {
	                this.decoderConfig.wasmBinary = libraries[1];
	            }
	            const fn = DRACOWorker.toString();
	            const body = [
	                '/* draco decoder */',
	                jsContent,
	                '',
	                '/* worker */',
	                fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))
	            ].join('\n');
	            this.workerSourceURL = URL.createObjectURL(new Blob([
	                body
	            ]));
	        });
	        return this.decoderPending;
	    }
	    _getWorker(taskID, taskCost) {
	        return this._initDecoder().then(()=>{
	            if (this.workerPool.length < this.workerLimit) {
	                const worker = new Worker(this.workerSourceURL);
	                worker._callbacks = {};
	                worker._taskCosts = {};
	                worker._taskLoad = 0;
	                worker.postMessage({
	                    type: 'init',
	                    decoderConfig: this.decoderConfig
	                });
	                worker.onmessage = function(e) {
	                    const message = e.data;
	                    switch(message.type){
	                        case 'decode':
	                            worker._callbacks[message.id].resolve(message);
	                            break;
	                        case 'error':
	                            worker._callbacks[message.id].reject(message);
	                            break;
	                        default:
	                            console.error('THREE.DRACOLoader: Unexpected message, "' + message.type + '"');
	                    }
	                };
	                this.workerPool.push(worker);
	            } else {
	                this.workerPool.sort(function(a, b) {
	                    return a._taskLoad > b._taskLoad ? -1 : 1;
	                });
	            }
	            const worker = this.workerPool[this.workerPool.length - 1];
	            worker._taskCosts[taskID] = taskCost;
	            worker._taskLoad += taskCost;
	            return worker;
	        });
	    }
	    _releaseTask(worker, taskID) {
	        worker._taskLoad -= worker._taskCosts[taskID];
	        delete worker._callbacks[taskID];
	        delete worker._taskCosts[taskID];
	    }
	    debug() {
	        console.log('Task load: ', this.workerPool.map((worker)=>worker._taskLoad));
	    }
	    dispose() {
	        for(let i = 0; i < this.workerPool.length; ++i){
	            this.workerPool[i].terminate();
	        }
	        this.workerPool.length = 0;
	        if (this.workerSourceURL !== '') {
	            URL.revokeObjectURL(this.workerSourceURL);
	        }
	        return this;
	    }
	    constructor(manager){
	        super(manager);
	        this.decoderPath = '';
	        this.decoderConfig = {};
	        this.decoderBinary = null;
	        this.decoderPending = null;
	        this.workerLimit = 4;
	        this.workerPool = [];
	        this.workerNextTaskID = 1;
	        this.workerSourceURL = '';
	        this.defaultAttributeIDs = {
	            position: 'POSITION',
	            normal: 'NORMAL',
	            color: 'COLOR',
	            uv: 'TEX_COORD'
	        };
	        this.defaultAttributeTypes = {
	            position: 'Float32Array',
	            normal: 'Float32Array',
	            color: 'Float32Array',
	            uv: 'Float32Array'
	        };
	    }
	}
	/* WEB WORKER */ function DRACOWorker() {
	    let decoderConfig;
	    let decoderPending;
	    onmessage = function(e) {
	        const message = e.data;
	        switch(message.type){
	            case 'init':
	                decoderConfig = message.decoderConfig;
	                decoderPending = new Promise(function(resolve /*, reject*/ ) {
	                    decoderConfig.onModuleLoaded = function(draco) {
	                        // Module is Promise-like. Wrap before resolving to avoid loop.
	                        resolve({
	                            draco: draco
	                        });
	                    };
	                    DracoDecoderModule(decoderConfig); // eslint-disable-line no-undef
	                });
	                break;
	            case 'decode':
	                const buffer = message.buffer;
	                const taskConfig = message.taskConfig;
	                decoderPending.then((module)=>{
	                    const draco = module.draco;
	                    const decoder = new draco.Decoder();
	                    try {
	                        const geometry = decodeGeometry(draco, decoder, new Int8Array(buffer), taskConfig);
	                        const buffers = geometry.attributes.map((attr)=>attr.array.buffer);
	                        if (geometry.index) buffers.push(geometry.index.array.buffer);
	                        self.postMessage({
	                            type: 'decode',
	                            id: message.id,
	                            geometry
	                        }, buffers);
	                    } catch (error) {
	                        console.error(error);
	                        self.postMessage({
	                            type: 'error',
	                            id: message.id,
	                            error: error.message
	                        });
	                    } finally{
	                        draco.destroy(decoder);
	                    }
	                });
	                break;
	        }
	    };
	    function decodeGeometry(draco, decoder, array, taskConfig) {
	        const attributeIDs = taskConfig.attributeIDs;
	        const attributeTypes = taskConfig.attributeTypes;
	        let dracoGeometry;
	        let decodingStatus;
	        const geometryType = decoder.GetEncodedGeometryType(array);
	        if (geometryType === draco.TRIANGULAR_MESH) {
	            dracoGeometry = new draco.Mesh();
	            decodingStatus = decoder.DecodeArrayToMesh(array, array.byteLength, dracoGeometry);
	        } else if (geometryType === draco.POINT_CLOUD) {
	            dracoGeometry = new draco.PointCloud();
	            decodingStatus = decoder.DecodeArrayToPointCloud(array, array.byteLength, dracoGeometry);
	        } else {
	            throw new Error('THREE.DRACOLoader: Unexpected geometry type.');
	        }
	        if (!decodingStatus.ok() || dracoGeometry.ptr === 0) {
	            throw new Error('THREE.DRACOLoader: Decoding failed: ' + decodingStatus.error_msg());
	        }
	        const geometry = {
	            index: null,
	            attributes: []
	        };
	        // Gather all vertex attributes.
	        for(const attributeName in attributeIDs){
	            const attributeType = self[attributeTypes[attributeName]];
	            let attribute;
	            let attributeID;
	            // A Draco file may be created with default vertex attributes, whose attribute IDs
	            // are mapped 1:1 from their semantic name (POSITION, NORMAL, ...). Alternatively,
	            // a Draco file may contain a custom set of attributes, identified by known unique
	            // IDs. glTF files always do the latter, and `.drc` files typically do the former.
	            if (taskConfig.useUniqueIDs) {
	                attributeID = attributeIDs[attributeName];
	                attribute = decoder.GetAttributeByUniqueId(dracoGeometry, attributeID);
	            } else {
	                attributeID = decoder.GetAttributeId(dracoGeometry, draco[attributeIDs[attributeName]]);
	                if (attributeID === -1) continue;
	                attribute = decoder.GetAttribute(dracoGeometry, attributeID);
	            }
	            const attributeResult = decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute);
	            if (attributeName === 'color') {
	                attributeResult.vertexColorSpace = taskConfig.vertexColorSpace;
	            }
	            geometry.attributes.push(attributeResult);
	        }
	        // Add index.
	        if (geometryType === draco.TRIANGULAR_MESH) {
	            geometry.index = decodeIndex(draco, decoder, dracoGeometry);
	        }
	        draco.destroy(dracoGeometry);
	        return geometry;
	    }
	    function decodeIndex(draco, decoder, dracoGeometry) {
	        const numFaces = dracoGeometry.num_faces();
	        const numIndices = numFaces * 3;
	        const byteLength = numIndices * 4;
	        const ptr = draco._malloc(byteLength);
	        decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
	        const index = new Uint32Array(draco.HEAPF32.buffer, ptr, numIndices).slice();
	        draco._free(ptr);
	        return {
	            array: index,
	            itemSize: 1
	        };
	    }
	    function decodeAttribute(draco, decoder, dracoGeometry, attributeName, attributeType, attribute) {
	        const numComponents = attribute.num_components();
	        const numPoints = dracoGeometry.num_points();
	        const numValues = numPoints * numComponents;
	        const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
	        const dataType = getDracoDataType(draco, attributeType);
	        const ptr = draco._malloc(byteLength);
	        decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr);
	        const array = new attributeType(draco.HEAPF32.buffer, ptr, numValues).slice();
	        draco._free(ptr);
	        return {
	            name: attributeName,
	            array: array,
	            itemSize: numComponents
	        };
	    }
	    function getDracoDataType(draco, attributeType) {
	        switch(attributeType){
	            case Float32Array:
	                return draco.DT_FLOAT32;
	            case Int8Array:
	                return draco.DT_INT8;
	            case Int16Array:
	                return draco.DT_INT16;
	            case Int32Array:
	                return draco.DT_INT32;
	            case Uint8Array:
	                return draco.DT_UINT8;
	            case Uint16Array:
	                return draco.DT_UINT16;
	            case Uint32Array:
	                return draco.DT_UINT32;
	        }
	    }
	}

	/**
	 * @param {BufferGeometry} geometry
	 * @param {number} drawMode
	 * @return {BufferGeometry}
	 */ function toTrianglesDrawMode(geometry, drawMode) {
	    if (drawMode === TrianglesDrawMode) {
	        console.warn('THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.');
	        return geometry;
	    }
	    if (drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode) {
	        let index = geometry.getIndex();
	        // generate index if not present
	        if (index === null) {
	            const indices = [];
	            const position = geometry.getAttribute('position');
	            if (position !== undefined) {
	                for(let i = 0; i < position.count; i++){
	                    indices.push(i);
	                }
	                geometry.setIndex(indices);
	                index = geometry.getIndex();
	            } else {
	                console.error('THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.');
	                return geometry;
	            }
	        }
	        //
	        const numberOfTriangles = index.count - 2;
	        const newIndices = [];
	        if (drawMode === TriangleFanDrawMode) {
	            // gl.TRIANGLE_FAN
	            for(let i = 1; i <= numberOfTriangles; i++){
	                newIndices.push(index.getX(0));
	                newIndices.push(index.getX(i));
	                newIndices.push(index.getX(i + 1));
	            }
	        } else {
	            // gl.TRIANGLE_STRIP
	            for(let i = 0; i < numberOfTriangles; i++){
	                if (i % 2 === 0) {
	                    newIndices.push(index.getX(i));
	                    newIndices.push(index.getX(i + 1));
	                    newIndices.push(index.getX(i + 2));
	                } else {
	                    newIndices.push(index.getX(i + 2));
	                    newIndices.push(index.getX(i + 1));
	                    newIndices.push(index.getX(i));
	                }
	            }
	        }
	        if (newIndices.length / 3 !== numberOfTriangles) {
	            console.error('THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.');
	        }
	        // build final geometry
	        const newGeometry = geometry.clone();
	        newGeometry.setIndex(newIndices);
	        newGeometry.clearGroups();
	        return newGeometry;
	    } else {
	        console.error('THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:', drawMode);
	        return geometry;
	    }
	}

	class GLTFLoader extends Loader {
	    load(url, onLoad, onProgress, onError) {
	        const scope = this;
	        let resourcePath;
	        if (this.resourcePath !== '') {
	            resourcePath = this.resourcePath;
	        } else if (this.path !== '') {
	            // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
	            // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
	            // resourcePath = 'https://my-cnd-server.com/assets/models/'
	            // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
	            // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
	            const relativeUrl = LoaderUtils.extractUrlBase(url);
	            resourcePath = LoaderUtils.resolveURL(relativeUrl, this.path);
	        } else {
	            resourcePath = LoaderUtils.extractUrlBase(url);
	        }
	        // Tells the LoadingManager to track an extra item, which resolves after
	        // the model is fully loaded. This means the count of items loaded will
	        // be incorrect, but ensures manager.onLoad() does not fire early.
	        this.manager.itemStart(url);
	        const _onError = function(e) {
	            if (onError) {
	                onError(e);
	            } else {
	                console.error(e);
	            }
	            scope.manager.itemError(url);
	            scope.manager.itemEnd(url);
	        };
	        const loader = new FileLoader(this.manager);
	        loader.setPath(this.path);
	        loader.setResponseType('arraybuffer');
	        loader.setRequestHeader(this.requestHeader);
	        loader.setWithCredentials(this.withCredentials);
	        loader.load(url, function(data) {
	            try {
	                scope.parse(data, resourcePath, function(gltf) {
	                    onLoad(gltf);
	                    scope.manager.itemEnd(url);
	                }, _onError);
	            } catch (e) {
	                _onError(e);
	            }
	        }, onProgress, _onError);
	    }
	    setDRACOLoader(dracoLoader) {
	        this.dracoLoader = dracoLoader;
	        return this;
	    }
	    setKTX2Loader(ktx2Loader) {
	        this.ktx2Loader = ktx2Loader;
	        return this;
	    }
	    setMeshoptDecoder(meshoptDecoder) {
	        this.meshoptDecoder = meshoptDecoder;
	        return this;
	    }
	    register(callback) {
	        if (this.pluginCallbacks.indexOf(callback) === -1) {
	            this.pluginCallbacks.push(callback);
	        }
	        return this;
	    }
	    unregister(callback) {
	        if (this.pluginCallbacks.indexOf(callback) !== -1) {
	            this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
	        }
	        return this;
	    }
	    parse(data, path, onLoad, onError) {
	        let json;
	        const extensions = {};
	        const plugins = {};
	        const textDecoder = new TextDecoder();
	        if (typeof data === 'string') {
	            json = JSON.parse(data);
	        } else if (data instanceof ArrayBuffer) {
	            const magic = textDecoder.decode(new Uint8Array(data, 0, 4));
	            if (magic === BINARY_EXTENSION_HEADER_MAGIC) {
	                try {
	                    extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(data);
	                } catch (error) {
	                    if (onError) onError(error);
	                    return;
	                }
	                json = JSON.parse(extensions[EXTENSIONS.KHR_BINARY_GLTF].content);
	            } else {
	                json = JSON.parse(textDecoder.decode(data));
	            }
	        } else {
	            json = data;
	        }
	        if (json.asset === undefined || json.asset.version[0] < 2) {
	            if (onError) onError(new Error('THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.'));
	            return;
	        }
	        const parser = new GLTFParser(json, {
	            path: path || this.resourcePath || '',
	            crossOrigin: this.crossOrigin,
	            requestHeader: this.requestHeader,
	            manager: this.manager,
	            ktx2Loader: this.ktx2Loader,
	            meshoptDecoder: this.meshoptDecoder
	        });
	        parser.fileLoader.setRequestHeader(this.requestHeader);
	        for(let i = 0; i < this.pluginCallbacks.length; i++){
	            const plugin = this.pluginCallbacks[i](parser);
	            if (!plugin.name) console.error('THREE.GLTFLoader: Invalid plugin found: missing name');
	            plugins[plugin.name] = plugin;
	            // Workaround to avoid determining as unknown extension
	            // in addUnknownExtensionsToUserData().
	            // Remove this workaround if we move all the existing
	            // extension handlers to plugin system
	            extensions[plugin.name] = true;
	        }
	        if (json.extensionsUsed) {
	            for(let i = 0; i < json.extensionsUsed.length; ++i){
	                const extensionName = json.extensionsUsed[i];
	                const extensionsRequired = json.extensionsRequired || [];
	                switch(extensionName){
	                    case EXTENSIONS.KHR_MATERIALS_UNLIT:
	                        extensions[extensionName] = new GLTFMaterialsUnlitExtension$1();
	                        break;
	                    case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
	                        extensions[extensionName] = new GLTFDracoMeshCompressionExtension(json, this.dracoLoader);
	                        break;
	                    case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
	                        extensions[extensionName] = new GLTFTextureTransformExtension();
	                        break;
	                    case EXTENSIONS.KHR_MESH_QUANTIZATION:
	                        extensions[extensionName] = new GLTFMeshQuantizationExtension();
	                        break;
	                    default:
	                        if (extensionsRequired.indexOf(extensionName) >= 0 && plugins[extensionName] === undefined) {
	                            console.warn('THREE.GLTFLoader: Unknown extension "' + extensionName + '".');
	                        }
	                }
	            }
	        }
	        parser.setExtensions(extensions);
	        parser.setPlugins(plugins);
	        parser.parse(onLoad, onError);
	    }
	    parseAsync(data, path) {
	        const scope = this;
	        return new Promise(function(resolve, reject) {
	            scope.parse(data, path, resolve, reject);
	        });
	    }
	    constructor(manager){
	        super(manager);
	        this.dracoLoader = null;
	        this.ktx2Loader = null;
	        this.meshoptDecoder = null;
	        this.pluginCallbacks = [];
	        this.register(function(parser) {
	            return new GLTFMaterialsClearcoatExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsDispersionExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFTextureBasisUExtension(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFTextureWebPExtension(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFTextureAVIFExtension(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsSheenExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsTransmissionExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsVolumeExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsIorExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsEmissiveStrengthExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsSpecularExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsIridescenceExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsAnisotropyExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMaterialsBumpExtension$1(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFLightsExtension(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMeshoptCompression(parser);
	        });
	        this.register(function(parser) {
	            return new GLTFMeshGpuInstancing$1(parser);
	        });
	    }
	}
	/* GLTFREGISTRY */ function GLTFRegistry() {
	    let objects = {};
	    return {
	        get: function(key) {
	            return objects[key];
	        },
	        add: function(key, object) {
	            objects[key] = object;
	        },
	        remove: function(key) {
	            delete objects[key];
	        },
	        removeAll: function() {
	            objects = {};
	        }
	    };
	}
	/*********************************/ /********** EXTENSIONS ***********/ /*********************************/ const EXTENSIONS = {
	    KHR_BINARY_GLTF: 'KHR_binary_glTF',
	    KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
	    KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
	    KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
	    KHR_MATERIALS_DISPERSION: 'KHR_materials_dispersion',
	    KHR_MATERIALS_IOR: 'KHR_materials_ior',
	    KHR_MATERIALS_SHEEN: 'KHR_materials_sheen',
	    KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
	    KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
	    KHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence',
	    KHR_MATERIALS_ANISOTROPY: 'KHR_materials_anisotropy',
	    KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
	    KHR_MATERIALS_VOLUME: 'KHR_materials_volume',
	    KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
	    KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
	    KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
	    KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',
	    EXT_MATERIALS_BUMP: 'EXT_materials_bump',
	    EXT_TEXTURE_WEBP: 'EXT_texture_webp',
	    EXT_TEXTURE_AVIF: 'EXT_texture_avif',
	    EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',
	    EXT_MESH_GPU_INSTANCING: 'EXT_mesh_gpu_instancing'
	};
	/**
	 * Punctual Lights Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
	 */ class GLTFLightsExtension {
	    _markDefs() {
	        const parser = this.parser;
	        const nodeDefs = this.parser.json.nodes || [];
	        for(let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++){
	            const nodeDef = nodeDefs[nodeIndex];
	            if (nodeDef.extensions && nodeDef.extensions[this.name] && nodeDef.extensions[this.name].light !== undefined) {
	                parser._addNodeRef(this.cache, nodeDef.extensions[this.name].light);
	            }
	        }
	    }
	    _loadLight(lightIndex) {
	        const parser = this.parser;
	        const cacheKey = 'light:' + lightIndex;
	        let dependency = parser.cache.get(cacheKey);
	        if (dependency) return dependency;
	        const json = parser.json;
	        const extensions = json.extensions && json.extensions[this.name] || {};
	        const lightDefs = extensions.lights || [];
	        const lightDef = lightDefs[lightIndex];
	        let lightNode;
	        const color = new Color(0xffffff);
	        if (lightDef.color !== undefined) color.setRGB(lightDef.color[0], lightDef.color[1], lightDef.color[2], LinearSRGBColorSpace);
	        const range = lightDef.range !== undefined ? lightDef.range : 0;
	        switch(lightDef.type){
	            case 'directional':
	                lightNode = new DirectionalLight(color);
	                lightNode.target.position.set(0, 0, -1);
	                lightNode.add(lightNode.target);
	                break;
	            case 'point':
	                lightNode = new PointLight(color);
	                lightNode.distance = range;
	                break;
	            case 'spot':
	                lightNode = new SpotLight(color);
	                lightNode.distance = range;
	                // Handle spotlight properties.
	                lightDef.spot = lightDef.spot || {};
	                lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
	                lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
	                lightNode.angle = lightDef.spot.outerConeAngle;
	                lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
	                lightNode.target.position.set(0, 0, -1);
	                lightNode.add(lightNode.target);
	                break;
	            default:
	                throw new Error('THREE.GLTFLoader: Unexpected light type: ' + lightDef.type);
	        }
	        // Some lights (e.g. spot) default to a position other than the origin. Reset the position
	        // here, because node-level parsing will only override position if explicitly specified.
	        lightNode.position.set(0, 0, 0);
	        assignExtrasToUserData(lightNode, lightDef);
	        if (lightDef.intensity !== undefined) lightNode.intensity = lightDef.intensity;
	        lightNode.name = parser.createUniqueName(lightDef.name || 'light_' + lightIndex);
	        dependency = Promise.resolve(lightNode);
	        parser.cache.add(cacheKey, dependency);
	        return dependency;
	    }
	    getDependency(type, index) {
	        if (type !== 'light') return;
	        return this._loadLight(index);
	    }
	    createNodeAttachment(nodeIndex) {
	        const self1 = this;
	        const parser = this.parser;
	        const json = parser.json;
	        const nodeDef = json.nodes[nodeIndex];
	        const lightDef = nodeDef.extensions && nodeDef.extensions[this.name] || {};
	        const lightIndex = lightDef.light;
	        if (lightIndex === undefined) return null;
	        return this._loadLight(lightIndex).then(function(light) {
	            return parser._getNodeRef(self1.cache, lightIndex, light);
	        });
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
	        // Object3D instance caches
	        this.cache = {
	            refs: {},
	            uses: {}
	        };
	    }
	}
	/**
	 * Unlit Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
	 */ let GLTFMaterialsUnlitExtension$1 = class GLTFMaterialsUnlitExtension {
	    getMaterialType() {
	        return MeshBasicMaterial;
	    }
	    extendParams(materialParams, materialDef, parser) {
	        const pending = [];
	        materialParams.color = new Color(1.0, 1.0, 1.0);
	        materialParams.opacity = 1.0;
	        const metallicRoughness = materialDef.pbrMetallicRoughness;
	        if (metallicRoughness) {
	            if (Array.isArray(metallicRoughness.baseColorFactor)) {
	                const array = metallicRoughness.baseColorFactor;
	                materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace);
	                materialParams.opacity = array[3];
	            }
	            if (metallicRoughness.baseColorTexture !== undefined) {
	                pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace));
	            }
	        }
	        return Promise.all(pending);
	    }
	    constructor(){
	        this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
	    }
	};
	/**
	 * Materials Emissive Strength Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md
	 */ let GLTFMaterialsEmissiveStrengthExtension$1 = class GLTFMaterialsEmissiveStrengthExtension {
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const emissiveStrength = materialDef.extensions[this.name].emissiveStrength;
	        if (emissiveStrength !== undefined) {
	            materialParams.emissiveIntensity = emissiveStrength;
	        }
	        return Promise.resolve();
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH;
	    }
	};
	/**
	 * Clearcoat Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
	 */ let GLTFMaterialsClearcoatExtension$1 = class GLTFMaterialsClearcoatExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        if (extension.clearcoatFactor !== undefined) {
	            materialParams.clearcoat = extension.clearcoatFactor;
	        }
	        if (extension.clearcoatTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'clearcoatMap', extension.clearcoatTexture));
	        }
	        if (extension.clearcoatRoughnessFactor !== undefined) {
	            materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
	        }
	        if (extension.clearcoatRoughnessTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture));
	        }
	        if (extension.clearcoatNormalTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture));
	            if (extension.clearcoatNormalTexture.scale !== undefined) {
	                const scale = extension.clearcoatNormalTexture.scale;
	                materialParams.clearcoatNormalScale = new Vector2(scale, scale);
	            }
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
	    }
	};
	/**
	 * Materials dispersion Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_dispersion
	 */ let GLTFMaterialsDispersionExtension$1 = class GLTFMaterialsDispersionExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const extension = materialDef.extensions[this.name];
	        materialParams.dispersion = extension.dispersion !== undefined ? extension.dispersion : 0;
	        return Promise.resolve();
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION;
	    }
	};
	/**
	 * Iridescence Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence
	 */ let GLTFMaterialsIridescenceExtension$1 = class GLTFMaterialsIridescenceExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        if (extension.iridescenceFactor !== undefined) {
	            materialParams.iridescence = extension.iridescenceFactor;
	        }
	        if (extension.iridescenceTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'iridescenceMap', extension.iridescenceTexture));
	        }
	        if (extension.iridescenceIor !== undefined) {
	            materialParams.iridescenceIOR = extension.iridescenceIor;
	        }
	        if (materialParams.iridescenceThicknessRange === undefined) {
	            materialParams.iridescenceThicknessRange = [
	                100,
	                400
	            ];
	        }
	        if (extension.iridescenceThicknessMinimum !== undefined) {
	            materialParams.iridescenceThicknessRange[0] = extension.iridescenceThicknessMinimum;
	        }
	        if (extension.iridescenceThicknessMaximum !== undefined) {
	            materialParams.iridescenceThicknessRange[1] = extension.iridescenceThicknessMaximum;
	        }
	        if (extension.iridescenceThicknessTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture));
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE;
	    }
	};
	/**
	 * Sheen Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
	 */ let GLTFMaterialsSheenExtension$1 = class GLTFMaterialsSheenExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        materialParams.sheenColor = new Color(0, 0, 0);
	        materialParams.sheenRoughness = 0;
	        materialParams.sheen = 1;
	        const extension = materialDef.extensions[this.name];
	        if (extension.sheenColorFactor !== undefined) {
	            const colorFactor = extension.sheenColorFactor;
	            materialParams.sheenColor.setRGB(colorFactor[0], colorFactor[1], colorFactor[2], LinearSRGBColorSpace);
	        }
	        if (extension.sheenRoughnessFactor !== undefined) {
	            materialParams.sheenRoughness = extension.sheenRoughnessFactor;
	        }
	        if (extension.sheenColorTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace));
	        }
	        if (extension.sheenRoughnessTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture));
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_SHEEN;
	    }
	};
	/**
	 * Transmission Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
	 * Draft: https://github.com/KhronosGroup/glTF/pull/1698
	 */ let GLTFMaterialsTransmissionExtension$1 = class GLTFMaterialsTransmissionExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        if (extension.transmissionFactor !== undefined) {
	            materialParams.transmission = extension.transmissionFactor;
	        }
	        if (extension.transmissionTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'transmissionMap', extension.transmissionTexture));
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;
	    }
	};
	/**
	 * Materials Volume Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume
	 */ let GLTFMaterialsVolumeExtension$1 = class GLTFMaterialsVolumeExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        materialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0;
	        if (extension.thicknessTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'thicknessMap', extension.thicknessTexture));
	        }
	        materialParams.attenuationDistance = extension.attenuationDistance || Infinity;
	        const colorArray = extension.attenuationColor || [
	            1,
	            1,
	            1
	        ];
	        materialParams.attenuationColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace);
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_VOLUME;
	    }
	};
	/**
	 * Materials ior Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior
	 */ let GLTFMaterialsIorExtension$1 = class GLTFMaterialsIorExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const extension = materialDef.extensions[this.name];
	        materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;
	        return Promise.resolve();
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_IOR;
	    }
	};
	/**
	 * Materials specular Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular
	 */ let GLTFMaterialsSpecularExtension$1 = class GLTFMaterialsSpecularExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        materialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0;
	        if (extension.specularTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'specularIntensityMap', extension.specularTexture));
	        }
	        const colorArray = extension.specularColorFactor || [
	            1,
	            1,
	            1
	        ];
	        materialParams.specularColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace);
	        if (extension.specularColorTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace));
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;
	    }
	};
	/**
	 * Materials bump Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump
	 */ let GLTFMaterialsBumpExtension$1 = class GLTFMaterialsBumpExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;
	        if (extension.bumpTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'bumpMap', extension.bumpTexture));
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.EXT_MATERIALS_BUMP;
	    }
	};
	/**
	 * Materials anisotropy Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_anisotropy
	 */ let GLTFMaterialsAnisotropyExtension$1 = class GLTFMaterialsAnisotropyExtension {
	    getMaterialType(materialIndex) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
	        return MeshPhysicalMaterial;
	    }
	    extendMaterialParams(materialIndex, materialParams) {
	        const parser = this.parser;
	        const materialDef = parser.json.materials[materialIndex];
	        if (!materialDef.extensions || !materialDef.extensions[this.name]) {
	            return Promise.resolve();
	        }
	        const pending = [];
	        const extension = materialDef.extensions[this.name];
	        if (extension.anisotropyStrength !== undefined) {
	            materialParams.anisotropy = extension.anisotropyStrength;
	        }
	        if (extension.anisotropyRotation !== undefined) {
	            materialParams.anisotropyRotation = extension.anisotropyRotation;
	        }
	        if (extension.anisotropyTexture !== undefined) {
	            pending.push(parser.assignTexture(materialParams, 'anisotropyMap', extension.anisotropyTexture));
	        }
	        return Promise.all(pending);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;
	    }
	};
	/**
	 * BasisU Texture Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu
	 */ class GLTFTextureBasisUExtension {
	    loadTexture(textureIndex) {
	        const parser = this.parser;
	        const json = parser.json;
	        const textureDef = json.textures[textureIndex];
	        if (!textureDef.extensions || !textureDef.extensions[this.name]) {
	            return null;
	        }
	        const extension = textureDef.extensions[this.name];
	        const loader = parser.options.ktx2Loader;
	        if (!loader) {
	            if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) {
	                throw new Error('THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures');
	            } else {
	                // Assumes that the extension is optional and that a fallback texture is present
	                return null;
	            }
	        }
	        return parser.loadTextureImage(textureIndex, extension.source, loader);
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.KHR_TEXTURE_BASISU;
	    }
	}
	/**
	 * WebP Texture Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
	 */ class GLTFTextureWebPExtension {
	    loadTexture(textureIndex) {
	        const name = this.name;
	        const parser = this.parser;
	        const json = parser.json;
	        const textureDef = json.textures[textureIndex];
	        if (!textureDef.extensions || !textureDef.extensions[name]) {
	            return null;
	        }
	        const extension = textureDef.extensions[name];
	        const source = json.images[extension.source];
	        let loader = parser.textureLoader;
	        if (source.uri) {
	            const handler = parser.options.manager.getHandler(source.uri);
	            if (handler !== null) loader = handler;
	        }
	        return this.detectSupport().then(function(isSupported) {
	            if (isSupported) return parser.loadTextureImage(textureIndex, extension.source, loader);
	            if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) {
	                throw new Error('THREE.GLTFLoader: WebP required by asset but unsupported.');
	            }
	            // Fall back to PNG or JPEG.
	            return parser.loadTexture(textureIndex);
	        });
	    }
	    detectSupport() {
	        if (!this.isSupported) {
	            this.isSupported = new Promise(function(resolve) {
	                const image = new Image();
	                // Lossy test image. Support for lossy images doesn't guarantee support for all
	                // WebP images, unfortunately.
	                image.src = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA';
	                image.onload = image.onerror = function() {
	                    resolve(image.height === 1);
	                };
	            });
	        }
	        return this.isSupported;
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.EXT_TEXTURE_WEBP;
	        this.isSupported = null;
	    }
	}
	/**
	 * AVIF Texture Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_avif
	 */ class GLTFTextureAVIFExtension {
	    loadTexture(textureIndex) {
	        const name = this.name;
	        const parser = this.parser;
	        const json = parser.json;
	        const textureDef = json.textures[textureIndex];
	        if (!textureDef.extensions || !textureDef.extensions[name]) {
	            return null;
	        }
	        const extension = textureDef.extensions[name];
	        const source = json.images[extension.source];
	        let loader = parser.textureLoader;
	        if (source.uri) {
	            const handler = parser.options.manager.getHandler(source.uri);
	            if (handler !== null) loader = handler;
	        }
	        return this.detectSupport().then(function(isSupported) {
	            if (isSupported) return parser.loadTextureImage(textureIndex, extension.source, loader);
	            if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) {
	                throw new Error('THREE.GLTFLoader: AVIF required by asset but unsupported.');
	            }
	            // Fall back to PNG or JPEG.
	            return parser.loadTexture(textureIndex);
	        });
	    }
	    detectSupport() {
	        if (!this.isSupported) {
	            this.isSupported = new Promise(function(resolve) {
	                const image = new Image();
	                // Lossy test image.
	                image.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=';
	                image.onload = image.onerror = function() {
	                    resolve(image.height === 1);
	                };
	            });
	        }
	        return this.isSupported;
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = EXTENSIONS.EXT_TEXTURE_AVIF;
	        this.isSupported = null;
	    }
	}
	/**
	 * meshopt BufferView Compression Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
	 */ class GLTFMeshoptCompression {
	    loadBufferView(index) {
	        const json = this.parser.json;
	        const bufferView = json.bufferViews[index];
	        if (bufferView.extensions && bufferView.extensions[this.name]) {
	            const extensionDef = bufferView.extensions[this.name];
	            const buffer = this.parser.getDependency('buffer', extensionDef.buffer);
	            const decoder = this.parser.options.meshoptDecoder;
	            if (!decoder || !decoder.supported) {
	                if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) {
	                    throw new Error('THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files');
	                } else {
	                    // Assumes that the extension is optional and that fallback buffer data is present
	                    return null;
	                }
	            }
	            return buffer.then(function(res) {
	                const byteOffset = extensionDef.byteOffset || 0;
	                const byteLength = extensionDef.byteLength || 0;
	                const count = extensionDef.count;
	                const stride = extensionDef.byteStride;
	                const source = new Uint8Array(res, byteOffset, byteLength);
	                if (decoder.decodeGltfBufferAsync) {
	                    return decoder.decodeGltfBufferAsync(count, stride, source, extensionDef.mode, extensionDef.filter).then(function(res) {
	                        return res.buffer;
	                    });
	                } else {
	                    // Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync
	                    return decoder.ready.then(function() {
	                        const result = new ArrayBuffer(count * stride);
	                        decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter);
	                        return result;
	                    });
	                }
	            });
	        } else {
	            return null;
	        }
	    }
	    constructor(parser){
	        this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION;
	        this.parser = parser;
	    }
	}
	/**
	 * GPU Instancing Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing
	 *
	 */ let GLTFMeshGpuInstancing$1 = class GLTFMeshGpuInstancing {
	    createNodeMesh(nodeIndex) {
	        const json = this.parser.json;
	        const nodeDef = json.nodes[nodeIndex];
	        if (!nodeDef.extensions || !nodeDef.extensions[this.name] || nodeDef.mesh === undefined) {
	            return null;
	        }
	        const meshDef = json.meshes[nodeDef.mesh];
	        // No Points or Lines + Instancing support yet
	        for (const primitive of meshDef.primitives){
	            if (primitive.mode !== WEBGL_CONSTANTS$1.TRIANGLES && primitive.mode !== WEBGL_CONSTANTS$1.TRIANGLE_STRIP && primitive.mode !== WEBGL_CONSTANTS$1.TRIANGLE_FAN && primitive.mode !== undefined) {
	                return null;
	            }
	        }
	        const extensionDef = nodeDef.extensions[this.name];
	        const attributesDef = extensionDef.attributes;
	        // @TODO: Can we support InstancedMesh + SkinnedMesh?
	        const pending = [];
	        const attributes = {};
	        for(const key in attributesDef){
	            pending.push(this.parser.getDependency('accessor', attributesDef[key]).then((accessor)=>{
	                attributes[key] = accessor;
	                return attributes[key];
	            }));
	        }
	        if (pending.length < 1) {
	            return null;
	        }
	        pending.push(this.parser.createNodeMesh(nodeIndex));
	        return Promise.all(pending).then((results)=>{
	            const nodeObject = results.pop();
	            const meshes = nodeObject.isGroup ? nodeObject.children : [
	                nodeObject
	            ];
	            const count = results[0].count; // All attribute counts should be same
	            const instancedMeshes = [];
	            for (const mesh of meshes){
	                // Temporal variables
	                const m = new Matrix4();
	                const p = new Vector3();
	                const q = new Quaternion();
	                const s = new Vector3(1, 1, 1);
	                const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, count);
	                for(let i = 0; i < count; i++){
	                    if (attributes.TRANSLATION) {
	                        p.fromBufferAttribute(attributes.TRANSLATION, i);
	                    }
	                    if (attributes.ROTATION) {
	                        q.fromBufferAttribute(attributes.ROTATION, i);
	                    }
	                    if (attributes.SCALE) {
	                        s.fromBufferAttribute(attributes.SCALE, i);
	                    }
	                    instancedMesh.setMatrixAt(i, m.compose(p, q, s));
	                }
	                // Add instance attributes to the geometry, excluding TRS.
	                for(const attributeName in attributes){
	                    if (attributeName === '_COLOR_0') {
	                        const attr = attributes[attributeName];
	                        instancedMesh.instanceColor = new InstancedBufferAttribute(attr.array, attr.itemSize, attr.normalized);
	                    } else if (attributeName !== 'TRANSLATION' && attributeName !== 'ROTATION' && attributeName !== 'SCALE') {
	                        mesh.geometry.setAttribute(attributeName, attributes[attributeName]);
	                    }
	                }
	                // Just in case
	                Object3D.prototype.copy.call(instancedMesh, mesh);
	                this.parser.assignFinalMaterial(instancedMesh);
	                instancedMeshes.push(instancedMesh);
	            }
	            if (nodeObject.isGroup) {
	                nodeObject.clear();
	                nodeObject.add(...instancedMeshes);
	                return nodeObject;
	            }
	            return instancedMeshes[0];
	        });
	    }
	    constructor(parser){
	        this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING;
	        this.parser = parser;
	    }
	};
	/* BINARY EXTENSION */ const BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
	const BINARY_EXTENSION_HEADER_LENGTH = 12;
	const BINARY_EXTENSION_CHUNK_TYPES = {
	    JSON: 0x4E4F534A,
	    BIN: 0x004E4942
	};
	class GLTFBinaryExtension {
	    constructor(data){
	        this.name = EXTENSIONS.KHR_BINARY_GLTF;
	        this.content = null;
	        this.body = null;
	        const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
	        const textDecoder = new TextDecoder();
	        this.header = {
	            magic: textDecoder.decode(new Uint8Array(data.slice(0, 4))),
	            version: headerView.getUint32(4, true),
	            length: headerView.getUint32(8, true)
	        };
	        if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
	            throw new Error('THREE.GLTFLoader: Unsupported glTF-Binary header.');
	        } else if (this.header.version < 2.0) {
	            throw new Error('THREE.GLTFLoader: Legacy binary file detected.');
	        }
	        const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
	        const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
	        let chunkIndex = 0;
	        while(chunkIndex < chunkContentsLength){
	            const chunkLength = chunkView.getUint32(chunkIndex, true);
	            chunkIndex += 4;
	            const chunkType = chunkView.getUint32(chunkIndex, true);
	            chunkIndex += 4;
	            if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
	                const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
	                this.content = textDecoder.decode(contentArray);
	            } else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
	                const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
	                this.body = data.slice(byteOffset, byteOffset + chunkLength);
	            }
	            // Clients must ignore chunks with unknown types.
	            chunkIndex += chunkLength;
	        }
	        if (this.content === null) {
	            throw new Error('THREE.GLTFLoader: JSON content not found.');
	        }
	    }
	}
	/**
	 * DRACO Mesh Compression Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
	 */ class GLTFDracoMeshCompressionExtension {
	    decodePrimitive(primitive, parser) {
	        const json = this.json;
	        const dracoLoader = this.dracoLoader;
	        const bufferViewIndex = primitive.extensions[this.name].bufferView;
	        const gltfAttributeMap = primitive.extensions[this.name].attributes;
	        const threeAttributeMap = {};
	        const attributeNormalizedMap = {};
	        const attributeTypeMap = {};
	        for(const attributeName in gltfAttributeMap){
	            const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
	            threeAttributeMap[threeAttributeName] = gltfAttributeMap[attributeName];
	        }
	        for(const attributeName in primitive.attributes){
	            const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
	            if (gltfAttributeMap[attributeName] !== undefined) {
	                const accessorDef = json.accessors[primitive.attributes[attributeName]];
	                const componentType = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
	                attributeTypeMap[threeAttributeName] = componentType.name;
	                attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true;
	            }
	        }
	        return parser.getDependency('bufferView', bufferViewIndex).then(function(bufferView) {
	            return new Promise(function(resolve, reject) {
	                dracoLoader.decodeDracoFile(bufferView, function(geometry) {
	                    for(const attributeName in geometry.attributes){
	                        const attribute = geometry.attributes[attributeName];
	                        const normalized = attributeNormalizedMap[attributeName];
	                        if (normalized !== undefined) attribute.normalized = normalized;
	                    }
	                    resolve(geometry);
	                }, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject);
	            });
	        });
	    }
	    constructor(json, dracoLoader){
	        if (!dracoLoader) {
	            throw new Error('THREE.GLTFLoader: No DRACOLoader instance provided.');
	        }
	        this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
	        this.json = json;
	        this.dracoLoader = dracoLoader;
	        this.dracoLoader.preload();
	    }
	}
	/**
	 * Texture Transform Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
	 */ class GLTFTextureTransformExtension {
	    extendTexture(texture, transform) {
	        if ((transform.texCoord === undefined || transform.texCoord === texture.channel) && transform.offset === undefined && transform.rotation === undefined && transform.scale === undefined) {
	            // See https://github.com/mrdoob/three.js/issues/21819.
	            return texture;
	        }
	        texture = texture.clone();
	        if (transform.texCoord !== undefined) {
	            texture.channel = transform.texCoord;
	        }
	        if (transform.offset !== undefined) {
	            texture.offset.fromArray(transform.offset);
	        }
	        if (transform.rotation !== undefined) {
	            texture.rotation = transform.rotation;
	        }
	        if (transform.scale !== undefined) {
	            texture.repeat.fromArray(transform.scale);
	        }
	        texture.needsUpdate = true;
	        return texture;
	    }
	    constructor(){
	        this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
	    }
	}
	/**
	 * Mesh Quantization Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
	 */ class GLTFMeshQuantizationExtension {
	    constructor(){
	        this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
	    }
	}
	/*********************************/ /********** INTERPOLATION ********/ /*********************************/ // Spline Interpolation
	// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
	class GLTFCubicSplineInterpolant extends Interpolant {
	    copySampleValue_(index) {
	        // Copies a sample value to the result buffer. See description of glTF
	        // CUBICSPLINE values layout in interpolate_() function below.
	        const result = this.resultBuffer, values = this.sampleValues, valueSize = this.valueSize, offset = index * valueSize * 3 + valueSize;
	        for(let i = 0; i !== valueSize; i++){
	            result[i] = values[offset + i];
	        }
	        return result;
	    }
	    interpolate_(i1, t0, t, t1) {
	        const result = this.resultBuffer;
	        const values = this.sampleValues;
	        const stride = this.valueSize;
	        const stride2 = stride * 2;
	        const stride3 = stride * 3;
	        const td = t1 - t0;
	        const p = (t - t0) / td;
	        const pp = p * p;
	        const ppp = pp * p;
	        const offset1 = i1 * stride3;
	        const offset0 = offset1 - stride3;
	        const s2 = -2 * ppp + 3 * pp;
	        const s3 = ppp - pp;
	        const s0 = 1 - s2;
	        const s1 = s3 - pp + p;
	        // Layout of keyframe output values for CUBICSPLINE animations:
	        //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
	        for(let i = 0; i !== stride; i++){
	            const p0 = values[offset0 + i + stride]; // splineVertex_k
	            const m0 = values[offset0 + i + stride2] * td; // outTangent_k * (t_k+1 - t_k)
	            const p1 = values[offset1 + i + stride]; // splineVertex_k+1
	            const m1 = values[offset1 + i] * td; // inTangent_k+1 * (t_k+1 - t_k)
	            result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
	        }
	        return result;
	    }
	    constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
	        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
	    }
	}
	const _q = new Quaternion();
	class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {
	    interpolate_(i1, t0, t, t1) {
	        const result = super.interpolate_(i1, t0, t, t1);
	        _q.fromArray(result).normalize().toArray(result);
	        return result;
	    }
	}
	/*********************************/ /********** INTERNALS ************/ /*********************************/ /* CONSTANTS */ const WEBGL_CONSTANTS$1 = {
	    POINTS: 0,
	    LINES: 1,
	    LINE_LOOP: 2,
	    LINE_STRIP: 3,
	    TRIANGLES: 4,
	    TRIANGLE_STRIP: 5,
	    TRIANGLE_FAN: 6};
	const WEBGL_COMPONENT_TYPES = {
	    5120: Int8Array,
	    5121: Uint8Array,
	    5122: Int16Array,
	    5123: Uint16Array,
	    5125: Uint32Array,
	    5126: Float32Array
	};
	const WEBGL_FILTERS = {
	    9728: NearestFilter,
	    9729: LinearFilter,
	    9984: NearestMipmapNearestFilter,
	    9985: LinearMipmapNearestFilter,
	    9986: NearestMipmapLinearFilter,
	    9987: LinearMipmapLinearFilter
	};
	const WEBGL_WRAPPINGS = {
	    33071: ClampToEdgeWrapping,
	    33648: MirroredRepeatWrapping,
	    10497: RepeatWrapping
	};
	const WEBGL_TYPE_SIZES = {
	    'SCALAR': 1,
	    'VEC2': 2,
	    'VEC3': 3,
	    'VEC4': 4,
	    'MAT2': 4,
	    'MAT3': 9,
	    'MAT4': 16
	};
	const ATTRIBUTES = {
	    POSITION: 'position',
	    NORMAL: 'normal',
	    TANGENT: 'tangent',
	    TEXCOORD_0: 'uv',
	    TEXCOORD_1: 'uv1',
	    TEXCOORD_2: 'uv2',
	    TEXCOORD_3: 'uv3',
	    COLOR_0: 'color',
	    WEIGHTS_0: 'skinWeight',
	    JOINTS_0: 'skinIndex'
	};
	const PATH_PROPERTIES$1 = {
	    scale: 'scale',
	    translation: 'position',
	    rotation: 'quaternion',
	    weights: 'morphTargetInfluences'
	};
	const INTERPOLATION = {
	    CUBICSPLINE: undefined,
	    // keyframe track will be initialized with a default interpolation type, then modified.
	    LINEAR: InterpolateLinear,
	    STEP: InterpolateDiscrete
	};
	const ALPHA_MODES = {
	    OPAQUE: 'OPAQUE',
	    MASK: 'MASK',
	    BLEND: 'BLEND'
	};
	/**
	 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
	 *
	 * @param {Object<string, Material>} cache
	 * @return {Material}
	 */ function createDefaultMaterial(cache) {
	    if (cache['DefaultMaterial'] === undefined) {
	        cache['DefaultMaterial'] = new MeshStandardMaterial({
	            color: 0xFFFFFF,
	            emissive: 0x000000,
	            metalness: 1,
	            roughness: 1,
	            transparent: false,
	            depthTest: true,
	            side: FrontSide
	        });
	    }
	    return cache['DefaultMaterial'];
	}
	function addUnknownExtensionsToUserData(knownExtensions, object, objectDef) {
	    // Add unknown glTF extensions to an object's userData.
	    for(const name in objectDef.extensions){
	        if (knownExtensions[name] === undefined) {
	            object.userData.gltfExtensions = object.userData.gltfExtensions || {};
	            object.userData.gltfExtensions[name] = objectDef.extensions[name];
	        }
	    }
	}
	/**
	 * @param {Object3D|Material|BufferGeometry} object
	 * @param {GLTF.definition} gltfDef
	 */ function assignExtrasToUserData(object, gltfDef) {
	    if (gltfDef.extras !== undefined) {
	        if (typeof gltfDef.extras === 'object') {
	            Object.assign(object.userData, gltfDef.extras);
	        } else {
	            console.warn('THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras);
	        }
	    }
	}
	/**
	 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
	 *
	 * @param {BufferGeometry} geometry
	 * @param {Array<GLTF.Target>} targets
	 * @param {GLTFParser} parser
	 * @return {Promise<BufferGeometry>}
	 */ function addMorphTargets(geometry, targets, parser) {
	    let hasMorphPosition = false;
	    let hasMorphNormal = false;
	    let hasMorphColor = false;
	    for(let i = 0, il = targets.length; i < il; i++){
	        const target = targets[i];
	        if (target.POSITION !== undefined) hasMorphPosition = true;
	        if (target.NORMAL !== undefined) hasMorphNormal = true;
	        if (target.COLOR_0 !== undefined) hasMorphColor = true;
	        if (hasMorphPosition && hasMorphNormal && hasMorphColor) break;
	    }
	    if (!hasMorphPosition && !hasMorphNormal && !hasMorphColor) return Promise.resolve(geometry);
	    const pendingPositionAccessors = [];
	    const pendingNormalAccessors = [];
	    const pendingColorAccessors = [];
	    for(let i = 0, il = targets.length; i < il; i++){
	        const target = targets[i];
	        if (hasMorphPosition) {
	            const pendingAccessor = target.POSITION !== undefined ? parser.getDependency('accessor', target.POSITION) : geometry.attributes.position;
	            pendingPositionAccessors.push(pendingAccessor);
	        }
	        if (hasMorphNormal) {
	            const pendingAccessor = target.NORMAL !== undefined ? parser.getDependency('accessor', target.NORMAL) : geometry.attributes.normal;
	            pendingNormalAccessors.push(pendingAccessor);
	        }
	        if (hasMorphColor) {
	            const pendingAccessor = target.COLOR_0 !== undefined ? parser.getDependency('accessor', target.COLOR_0) : geometry.attributes.color;
	            pendingColorAccessors.push(pendingAccessor);
	        }
	    }
	    return Promise.all([
	        Promise.all(pendingPositionAccessors),
	        Promise.all(pendingNormalAccessors),
	        Promise.all(pendingColorAccessors)
	    ]).then(function(accessors) {
	        const morphPositions = accessors[0];
	        const morphNormals = accessors[1];
	        const morphColors = accessors[2];
	        if (hasMorphPosition) geometry.morphAttributes.position = morphPositions;
	        if (hasMorphNormal) geometry.morphAttributes.normal = morphNormals;
	        if (hasMorphColor) geometry.morphAttributes.color = morphColors;
	        geometry.morphTargetsRelative = true;
	        return geometry;
	    });
	}
	/**
	 * @param {Mesh} mesh
	 * @param {GLTF.Mesh} meshDef
	 */ function updateMorphTargets(mesh, meshDef) {
	    mesh.updateMorphTargets();
	    if (meshDef.weights !== undefined) {
	        for(let i = 0, il = meshDef.weights.length; i < il; i++){
	            mesh.morphTargetInfluences[i] = meshDef.weights[i];
	        }
	    }
	    // .extras has user-defined data, so check that .extras.targetNames is an array.
	    if (meshDef.extras && Array.isArray(meshDef.extras.targetNames)) {
	        const targetNames = meshDef.extras.targetNames;
	        if (mesh.morphTargetInfluences.length === targetNames.length) {
	            mesh.morphTargetDictionary = {};
	            for(let i = 0, il = targetNames.length; i < il; i++){
	                mesh.morphTargetDictionary[targetNames[i]] = i;
	            }
	        } else {
	            console.warn('THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.');
	        }
	    }
	}
	function createPrimitiveKey(primitiveDef) {
	    let geometryKey;
	    const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION];
	    if (dracoExtension) {
	        geometryKey = 'draco:' + dracoExtension.bufferView + ':' + dracoExtension.indices + ':' + createAttributesKey(dracoExtension.attributes);
	    } else {
	        geometryKey = primitiveDef.indices + ':' + createAttributesKey(primitiveDef.attributes) + ':' + primitiveDef.mode;
	    }
	    if (primitiveDef.targets !== undefined) {
	        for(let i = 0, il = primitiveDef.targets.length; i < il; i++){
	            geometryKey += ':' + createAttributesKey(primitiveDef.targets[i]);
	        }
	    }
	    return geometryKey;
	}
	function createAttributesKey(attributes) {
	    let attributesKey = '';
	    const keys = Object.keys(attributes).sort();
	    for(let i = 0, il = keys.length; i < il; i++){
	        attributesKey += keys[i] + ':' + attributes[keys[i]] + ';';
	    }
	    return attributesKey;
	}
	function getNormalizedComponentScale(constructor) {
	    // Reference:
	    // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data
	    switch(constructor){
	        case Int8Array:
	            return 1 / 127;
	        case Uint8Array:
	            return 1 / 255;
	        case Int16Array:
	            return 1 / 32767;
	        case Uint16Array:
	            return 1 / 65535;
	        default:
	            throw new Error('THREE.GLTFLoader: Unsupported normalized accessor component type.');
	    }
	}
	function getImageURIMimeType(uri) {
	    if (uri.search(/\.jpe?g($|\?)/i) > 0 || uri.search(/^data\:image\/jpeg/) === 0) return 'image/jpeg';
	    if (uri.search(/\.webp($|\?)/i) > 0 || uri.search(/^data\:image\/webp/) === 0) return 'image/webp';
	    if (uri.search(/\.ktx2($|\?)/i) > 0 || uri.search(/^data\:image\/ktx2/) === 0) return 'image/ktx2';
	    return 'image/png';
	}
	const _identityMatrix = new Matrix4();
	/* GLTF PARSER */ class GLTFParser {
	    setExtensions(extensions) {
	        this.extensions = extensions;
	    }
	    setPlugins(plugins) {
	        this.plugins = plugins;
	    }
	    parse(onLoad, onError) {
	        const parser = this;
	        const json = this.json;
	        const extensions = this.extensions;
	        // Clear the loader cache
	        this.cache.removeAll();
	        this.nodeCache = {};
	        // Mark the special nodes/meshes in json for efficient parse
	        this._invokeAll(function(ext) {
	            return ext._markDefs && ext._markDefs();
	        });
	        Promise.all(this._invokeAll(function(ext) {
	            return ext.beforeRoot && ext.beforeRoot();
	        })).then(function() {
	            return Promise.all([
	                parser.getDependencies('scene'),
	                parser.getDependencies('animation'),
	                parser.getDependencies('camera')
	            ]);
	        }).then(function(dependencies) {
	            const result = {
	                scene: dependencies[0][json.scene || 0],
	                scenes: dependencies[0],
	                animations: dependencies[1],
	                cameras: dependencies[2],
	                asset: json.asset,
	                parser: parser,
	                userData: {}
	            };
	            addUnknownExtensionsToUserData(extensions, result, json);
	            assignExtrasToUserData(result, json);
	            return Promise.all(parser._invokeAll(function(ext) {
	                return ext.afterRoot && ext.afterRoot(result);
	            })).then(function() {
	                for (const scene of result.scenes){
	                    scene.updateMatrixWorld();
	                }
	                onLoad(result);
	            });
	        }).catch(onError);
	    }
	    /**
		 * Marks the special nodes/meshes in json for efficient parse.
		 */ _markDefs() {
	        const nodeDefs = this.json.nodes || [];
	        const skinDefs = this.json.skins || [];
	        const meshDefs = this.json.meshes || [];
	        // Nothing in the node definition indicates whether it is a Bone or an
	        // Object3D. Use the skins' joint references to mark bones.
	        for(let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex++){
	            const joints = skinDefs[skinIndex].joints;
	            for(let i = 0, il = joints.length; i < il; i++){
	                nodeDefs[joints[i]].isBone = true;
	            }
	        }
	        // Iterate over all nodes, marking references to shared resources,
	        // as well as skeleton joints.
	        for(let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++){
	            const nodeDef = nodeDefs[nodeIndex];
	            if (nodeDef.mesh !== undefined) {
	                this._addNodeRef(this.meshCache, nodeDef.mesh);
	                // Nothing in the mesh definition indicates whether it is
	                // a SkinnedMesh or Mesh. Use the node's mesh reference
	                // to mark SkinnedMesh if node has skin.
	                if (nodeDef.skin !== undefined) {
	                    meshDefs[nodeDef.mesh].isSkinnedMesh = true;
	                }
	            }
	            if (nodeDef.camera !== undefined) {
	                this._addNodeRef(this.cameraCache, nodeDef.camera);
	            }
	        }
	    }
	    /**
		 * Counts references to shared node / Object3D resources. These resources
		 * can be reused, or "instantiated", at multiple nodes in the scene
		 * hierarchy. Mesh, Camera, and Light instances are instantiated and must
		 * be marked. Non-scenegraph resources (like Materials, Geometries, and
		 * Textures) can be reused directly and are not marked here.
		 *
		 * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
		 *
		 * @param {Object} cache
		 * @param {Object3D} index
		 */ _addNodeRef(cache, index) {
	        if (index === undefined) return;
	        if (cache.refs[index] === undefined) {
	            cache.refs[index] = cache.uses[index] = 0;
	        }
	        cache.refs[index]++;
	    }
	    /**
		 * Returns a reference to a shared resource, cloning it if necessary.
		 *
		 * @param {Object} cache
		 * @param {number} index
		 * @param {Object} object
		 * @return {Object}
		 */ _getNodeRef(cache, index, object) {
	        if (cache.refs[index] <= 1) return object;
	        const ref = object.clone();
	        // Propagates mappings to the cloned object, prevents mappings on the
	        // original object from being lost.
	        const updateMappings = (original, clone)=>{
	            const mappings = this.associations.get(original);
	            if (mappings != null) {
	                this.associations.set(clone, mappings);
	            }
	            for (const [i, child] of original.children.entries()){
	                updateMappings(child, clone.children[i]);
	            }
	        };
	        updateMappings(object, ref);
	        ref.name += '_instance_' + cache.uses[index]++;
	        return ref;
	    }
	    _invokeOne(func) {
	        const extensions = Object.values(this.plugins);
	        extensions.push(this);
	        for(let i = 0; i < extensions.length; i++){
	            const result = func(extensions[i]);
	            if (result) return result;
	        }
	        return null;
	    }
	    _invokeAll(func) {
	        const extensions = Object.values(this.plugins);
	        extensions.unshift(this);
	        const pending = [];
	        for(let i = 0; i < extensions.length; i++){
	            const result = func(extensions[i]);
	            if (result) pending.push(result);
	        }
	        return pending;
	    }
	    /**
		 * Requests the specified dependency asynchronously, with caching.
		 * @param {string} type
		 * @param {number} index
		 * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
		 */ getDependency(type, index) {
	        const cacheKey = type + ':' + index;
	        let dependency = this.cache.get(cacheKey);
	        if (!dependency) {
	            switch(type){
	                case 'scene':
	                    dependency = this.loadScene(index);
	                    break;
	                case 'node':
	                    dependency = this._invokeOne(function(ext) {
	                        return ext.loadNode && ext.loadNode(index);
	                    });
	                    break;
	                case 'mesh':
	                    dependency = this._invokeOne(function(ext) {
	                        return ext.loadMesh && ext.loadMesh(index);
	                    });
	                    break;
	                case 'accessor':
	                    dependency = this.loadAccessor(index);
	                    break;
	                case 'bufferView':
	                    dependency = this._invokeOne(function(ext) {
	                        return ext.loadBufferView && ext.loadBufferView(index);
	                    });
	                    break;
	                case 'buffer':
	                    dependency = this.loadBuffer(index);
	                    break;
	                case 'material':
	                    dependency = this._invokeOne(function(ext) {
	                        return ext.loadMaterial && ext.loadMaterial(index);
	                    });
	                    break;
	                case 'texture':
	                    dependency = this._invokeOne(function(ext) {
	                        return ext.loadTexture && ext.loadTexture(index);
	                    });
	                    break;
	                case 'skin':
	                    dependency = this.loadSkin(index);
	                    break;
	                case 'animation':
	                    dependency = this._invokeOne(function(ext) {
	                        return ext.loadAnimation && ext.loadAnimation(index);
	                    });
	                    break;
	                case 'camera':
	                    dependency = this.loadCamera(index);
	                    break;
	                default:
	                    dependency = this._invokeOne(function(ext) {
	                        return ext != this && ext.getDependency && ext.getDependency(type, index);
	                    });
	                    if (!dependency) {
	                        throw new Error('Unknown type: ' + type);
	                    }
	                    break;
	            }
	            this.cache.add(cacheKey, dependency);
	        }
	        return dependency;
	    }
	    /**
		 * Requests all dependencies of the specified type asynchronously, with caching.
		 * @param {string} type
		 * @return {Promise<Array<Object>>}
		 */ getDependencies(type) {
	        let dependencies = this.cache.get(type);
	        if (!dependencies) {
	            const parser = this;
	            const defs = this.json[type + (type === 'mesh' ? 'es' : 's')] || [];
	            dependencies = Promise.all(defs.map(function(def, index) {
	                return parser.getDependency(type, index);
	            }));
	            this.cache.add(type, dependencies);
	        }
	        return dependencies;
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
		 * @param {number} bufferIndex
		 * @return {Promise<ArrayBuffer>}
		 */ loadBuffer(bufferIndex) {
	        const bufferDef = this.json.buffers[bufferIndex];
	        const loader = this.fileLoader;
	        if (bufferDef.type && bufferDef.type !== 'arraybuffer') {
	            throw new Error('THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.');
	        }
	        // If present, GLB container is required to be the first buffer.
	        if (bufferDef.uri === undefined && bufferIndex === 0) {
	            return Promise.resolve(this.extensions[EXTENSIONS.KHR_BINARY_GLTF].body);
	        }
	        const options = this.options;
	        return new Promise(function(resolve, reject) {
	            loader.load(LoaderUtils.resolveURL(bufferDef.uri, options.path), resolve, undefined, function() {
	                reject(new Error('THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".'));
	            });
	        });
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
		 * @param {number} bufferViewIndex
		 * @return {Promise<ArrayBuffer>}
		 */ loadBufferView(bufferViewIndex) {
	        const bufferViewDef = this.json.bufferViews[bufferViewIndex];
	        return this.getDependency('buffer', bufferViewDef.buffer).then(function(buffer) {
	            const byteLength = bufferViewDef.byteLength || 0;
	            const byteOffset = bufferViewDef.byteOffset || 0;
	            return buffer.slice(byteOffset, byteOffset + byteLength);
	        });
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
		 * @param {number} accessorIndex
		 * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
		 */ loadAccessor(accessorIndex) {
	        const parser = this;
	        const json = this.json;
	        const accessorDef = this.json.accessors[accessorIndex];
	        if (accessorDef.bufferView === undefined && accessorDef.sparse === undefined) {
	            const itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
	            const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
	            const normalized = accessorDef.normalized === true;
	            const array = new TypedArray(accessorDef.count * itemSize);
	            return Promise.resolve(new BufferAttribute(array, itemSize, normalized));
	        }
	        const pendingBufferViews = [];
	        if (accessorDef.bufferView !== undefined) {
	            pendingBufferViews.push(this.getDependency('bufferView', accessorDef.bufferView));
	        } else {
	            pendingBufferViews.push(null);
	        }
	        if (accessorDef.sparse !== undefined) {
	            pendingBufferViews.push(this.getDependency('bufferView', accessorDef.sparse.indices.bufferView));
	            pendingBufferViews.push(this.getDependency('bufferView', accessorDef.sparse.values.bufferView));
	        }
	        return Promise.all(pendingBufferViews).then(function(bufferViews) {
	            const bufferView = bufferViews[0];
	            const itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
	            const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
	            // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
	            const elementBytes = TypedArray.BYTES_PER_ELEMENT;
	            const itemBytes = elementBytes * itemSize;
	            const byteOffset = accessorDef.byteOffset || 0;
	            const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[accessorDef.bufferView].byteStride : undefined;
	            const normalized = accessorDef.normalized === true;
	            let array, bufferAttribute;
	            // The buffer is not interleaved if the stride is the item size in bytes.
	            if (byteStride && byteStride !== itemBytes) {
	                // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
	                // This makes sure that IBA.count reflects accessor.count properly
	                const ibSlice = Math.floor(byteOffset / byteStride);
	                const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
	                let ib = parser.cache.get(ibCacheKey);
	                if (!ib) {
	                    array = new TypedArray(bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes);
	                    // Integer parameters to IB/IBA are in array elements, not bytes.
	                    ib = new InterleavedBuffer(array, byteStride / elementBytes);
	                    parser.cache.add(ibCacheKey, ib);
	                }
	                bufferAttribute = new InterleavedBufferAttribute(ib, itemSize, byteOffset % byteStride / elementBytes, normalized);
	            } else {
	                if (bufferView === null) {
	                    array = new TypedArray(accessorDef.count * itemSize);
	                } else {
	                    array = new TypedArray(bufferView, byteOffset, accessorDef.count * itemSize);
	                }
	                bufferAttribute = new BufferAttribute(array, itemSize, normalized);
	            }
	            // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
	            if (accessorDef.sparse !== undefined) {
	                const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
	                const TypedArrayIndices = WEBGL_COMPONENT_TYPES[accessorDef.sparse.indices.componentType];
	                const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
	                const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
	                const sparseIndices = new TypedArrayIndices(bufferViews[1], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices);
	                const sparseValues = new TypedArray(bufferViews[2], byteOffsetValues, accessorDef.sparse.count * itemSize);
	                if (bufferView !== null) {
	                    // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
	                    bufferAttribute = new BufferAttribute(bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized);
	                }
	                // Ignore normalized since we copy from sparse
	                bufferAttribute.normalized = false;
	                for(let i = 0, il = sparseIndices.length; i < il; i++){
	                    const index = sparseIndices[i];
	                    bufferAttribute.setX(index, sparseValues[i * itemSize]);
	                    if (itemSize >= 2) bufferAttribute.setY(index, sparseValues[i * itemSize + 1]);
	                    if (itemSize >= 3) bufferAttribute.setZ(index, sparseValues[i * itemSize + 2]);
	                    if (itemSize >= 4) bufferAttribute.setW(index, sparseValues[i * itemSize + 3]);
	                    if (itemSize >= 5) throw new Error('THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.');
	                }
	                bufferAttribute.normalized = normalized;
	            }
	            return bufferAttribute;
	        });
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
		 * @param {number} textureIndex
		 * @return {Promise<THREE.Texture|null>}
		 */ loadTexture(textureIndex) {
	        const json = this.json;
	        const options = this.options;
	        const textureDef = json.textures[textureIndex];
	        const sourceIndex = textureDef.source;
	        const sourceDef = json.images[sourceIndex];
	        let loader = this.textureLoader;
	        if (sourceDef.uri) {
	            const handler = options.manager.getHandler(sourceDef.uri);
	            if (handler !== null) loader = handler;
	        }
	        return this.loadTextureImage(textureIndex, sourceIndex, loader);
	    }
	    loadTextureImage(textureIndex, sourceIndex, loader) {
	        const parser = this;
	        const json = this.json;
	        const textureDef = json.textures[textureIndex];
	        const sourceDef = json.images[sourceIndex];
	        const cacheKey = (sourceDef.uri || sourceDef.bufferView) + ':' + textureDef.sampler;
	        if (this.textureCache[cacheKey]) {
	            // See https://github.com/mrdoob/three.js/issues/21559.
	            return this.textureCache[cacheKey];
	        }
	        const promise = this.loadImageSource(sourceIndex, loader).then(function(texture) {
	            texture.flipY = false;
	            texture.name = textureDef.name || sourceDef.name || '';
	            if (texture.name === '' && typeof sourceDef.uri === 'string' && sourceDef.uri.startsWith('data:image/') === false) {
	                texture.name = sourceDef.uri;
	            }
	            const samplers = json.samplers || {};
	            const sampler = samplers[textureDef.sampler] || {};
	            texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || LinearFilter;
	            texture.minFilter = WEBGL_FILTERS[sampler.minFilter] || LinearMipmapLinearFilter;
	            texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || RepeatWrapping;
	            texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || RepeatWrapping;
	            texture.generateMipmaps = !texture.isCompressedTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;
	            parser.associations.set(texture, {
	                textures: textureIndex
	            });
	            return texture;
	        }).catch(function() {
	            return null;
	        });
	        this.textureCache[cacheKey] = promise;
	        return promise;
	    }
	    loadImageSource(sourceIndex, loader) {
	        const parser = this;
	        const json = this.json;
	        const options = this.options;
	        if (this.sourceCache[sourceIndex] !== undefined) {
	            return this.sourceCache[sourceIndex].then((texture)=>texture.clone());
	        }
	        const sourceDef = json.images[sourceIndex];
	        const URL = self.URL || self.webkitURL;
	        let sourceURI = sourceDef.uri || '';
	        let isObjectURL = false;
	        if (sourceDef.bufferView !== undefined) {
	            // Load binary image data from bufferView, if provided.
	            sourceURI = parser.getDependency('bufferView', sourceDef.bufferView).then(function(bufferView) {
	                isObjectURL = true;
	                const blob = new Blob([
	                    bufferView
	                ], {
	                    type: sourceDef.mimeType
	                });
	                sourceURI = URL.createObjectURL(blob);
	                return sourceURI;
	            });
	        } else if (sourceDef.uri === undefined) {
	            throw new Error('THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView');
	        }
	        const promise = Promise.resolve(sourceURI).then(function(sourceURI) {
	            return new Promise(function(resolve, reject) {
	                let onLoad = resolve;
	                if (loader.isImageBitmapLoader === true) {
	                    onLoad = function(imageBitmap) {
	                        const texture = new Texture$1(imageBitmap);
	                        texture.needsUpdate = true;
	                        resolve(texture);
	                    };
	                }
	                loader.load(LoaderUtils.resolveURL(sourceURI, options.path), onLoad, undefined, reject);
	            });
	        }).then(function(texture) {
	            // Clean up resources and configure Texture.
	            if (isObjectURL === true) {
	                URL.revokeObjectURL(sourceURI);
	            }
	            assignExtrasToUserData(texture, sourceDef);
	            texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri);
	            return texture;
	        }).catch(function(error) {
	            console.error('THREE.GLTFLoader: Couldn\'t load texture', sourceURI);
	            throw error;
	        });
	        this.sourceCache[sourceIndex] = promise;
	        return promise;
	    }
	    /**
		 * Asynchronously assigns a texture to the given material parameters.
		 *
		 * @param {Object} materialParams
		 * @param {string} mapName
		 * @param {Object} mapDef
		 * @param {string} colorSpace
		 * @return {Promise<Texture>}
		 */ assignTexture(materialParams, mapName, mapDef, colorSpace) {
	        const parser = this;
	        return this.getDependency('texture', mapDef.index).then(function(texture) {
	            if (!texture) return null;
	            if (mapDef.texCoord !== undefined && mapDef.texCoord > 0) {
	                texture = texture.clone();
	                texture.channel = mapDef.texCoord;
	            }
	            if (parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM]) {
	                const transform = mapDef.extensions !== undefined ? mapDef.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM] : undefined;
	                if (transform) {
	                    const gltfReference = parser.associations.get(texture);
	                    texture = parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM].extendTexture(texture, transform);
	                    parser.associations.set(texture, gltfReference);
	                }
	            }
	            if (colorSpace !== undefined) {
	                texture.colorSpace = colorSpace;
	            }
	            materialParams[mapName] = texture;
	            return texture;
	        });
	    }
	    /**
		 * Assigns final material to a Mesh, Line, or Points instance. The instance
		 * already has a material (generated from the glTF material options alone)
		 * but reuse of the same glTF material may require multiple threejs materials
		 * to accommodate different primitive types, defines, etc. New materials will
		 * be created if necessary, and reused from a cache.
		 * @param  {Object3D} mesh Mesh, Line, or Points instance.
		 */ assignFinalMaterial(mesh) {
	        const geometry = mesh.geometry;
	        let material = mesh.material;
	        const useDerivativeTangents = geometry.attributes.tangent === undefined;
	        const useVertexColors = geometry.attributes.color !== undefined;
	        const useFlatShading = geometry.attributes.normal === undefined;
	        if (mesh.isPoints) {
	            const cacheKey = 'PointsMaterial:' + material.uuid;
	            let pointsMaterial = this.cache.get(cacheKey);
	            if (!pointsMaterial) {
	                pointsMaterial = new PointsMaterial();
	                Material$1.prototype.copy.call(pointsMaterial, material);
	                pointsMaterial.color.copy(material.color);
	                pointsMaterial.map = material.map;
	                pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px
	                this.cache.add(cacheKey, pointsMaterial);
	            }
	            material = pointsMaterial;
	        } else if (mesh.isLine) {
	            const cacheKey = 'LineBasicMaterial:' + material.uuid;
	            let lineMaterial = this.cache.get(cacheKey);
	            if (!lineMaterial) {
	                lineMaterial = new LineBasicMaterial();
	                Material$1.prototype.copy.call(lineMaterial, material);
	                lineMaterial.color.copy(material.color);
	                lineMaterial.map = material.map;
	                this.cache.add(cacheKey, lineMaterial);
	            }
	            material = lineMaterial;
	        }
	        // Clone the material if it will be modified
	        if (useDerivativeTangents || useVertexColors || useFlatShading) {
	            let cacheKey = 'ClonedMaterial:' + material.uuid + ':';
	            if (useDerivativeTangents) cacheKey += 'derivative-tangents:';
	            if (useVertexColors) cacheKey += 'vertex-colors:';
	            if (useFlatShading) cacheKey += 'flat-shading:';
	            let cachedMaterial = this.cache.get(cacheKey);
	            if (!cachedMaterial) {
	                cachedMaterial = material.clone();
	                if (useVertexColors) cachedMaterial.vertexColors = true;
	                if (useFlatShading) cachedMaterial.flatShading = true;
	                if (useDerivativeTangents) {
	                    // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
	                    if (cachedMaterial.normalScale) cachedMaterial.normalScale.y *= -1;
	                    if (cachedMaterial.clearcoatNormalScale) cachedMaterial.clearcoatNormalScale.y *= -1;
	                }
	                this.cache.add(cacheKey, cachedMaterial);
	                this.associations.set(cachedMaterial, this.associations.get(material));
	            }
	            material = cachedMaterial;
	        }
	        mesh.material = material;
	    }
	    getMaterialType() {
	        return MeshStandardMaterial;
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
		 * @param {number} materialIndex
		 * @return {Promise<Material>}
		 */ loadMaterial(materialIndex) {
	        const parser = this;
	        const json = this.json;
	        const extensions = this.extensions;
	        const materialDef = json.materials[materialIndex];
	        let materialType;
	        const materialParams = {};
	        const materialExtensions = materialDef.extensions || {};
	        const pending = [];
	        if (materialExtensions[EXTENSIONS.KHR_MATERIALS_UNLIT]) {
	            const kmuExtension = extensions[EXTENSIONS.KHR_MATERIALS_UNLIT];
	            materialType = kmuExtension.getMaterialType();
	            pending.push(kmuExtension.extendParams(materialParams, materialDef, parser));
	        } else {
	            // Specification:
	            // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material
	            const metallicRoughness = materialDef.pbrMetallicRoughness || {};
	            materialParams.color = new Color(1.0, 1.0, 1.0);
	            materialParams.opacity = 1.0;
	            if (Array.isArray(metallicRoughness.baseColorFactor)) {
	                const array = metallicRoughness.baseColorFactor;
	                materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace);
	                materialParams.opacity = array[3];
	            }
	            if (metallicRoughness.baseColorTexture !== undefined) {
	                pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace));
	            }
	            materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
	            materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;
	            if (metallicRoughness.metallicRoughnessTexture !== undefined) {
	                pending.push(parser.assignTexture(materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture));
	                pending.push(parser.assignTexture(materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture));
	            }
	            materialType = this._invokeOne(function(ext) {
	                return ext.getMaterialType && ext.getMaterialType(materialIndex);
	            });
	            pending.push(Promise.all(this._invokeAll(function(ext) {
	                return ext.extendMaterialParams && ext.extendMaterialParams(materialIndex, materialParams);
	            })));
	        }
	        if (materialDef.doubleSided === true) {
	            materialParams.side = DoubleSide;
	        }
	        const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
	        if (alphaMode === ALPHA_MODES.BLEND) {
	            materialParams.transparent = true;
	            // See: https://github.com/mrdoob/three.js/issues/17706
	            materialParams.depthWrite = false;
	        } else {
	            materialParams.transparent = false;
	            if (alphaMode === ALPHA_MODES.MASK) {
	                materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
	            }
	        }
	        if (materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial) {
	            pending.push(parser.assignTexture(materialParams, 'normalMap', materialDef.normalTexture));
	            materialParams.normalScale = new Vector2(1, 1);
	            if (materialDef.normalTexture.scale !== undefined) {
	                const scale = materialDef.normalTexture.scale;
	                materialParams.normalScale.set(scale, scale);
	            }
	        }
	        if (materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial) {
	            pending.push(parser.assignTexture(materialParams, 'aoMap', materialDef.occlusionTexture));
	            if (materialDef.occlusionTexture.strength !== undefined) {
	                materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
	            }
	        }
	        if (materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial) {
	            const emissiveFactor = materialDef.emissiveFactor;
	            materialParams.emissive = new Color().setRGB(emissiveFactor[0], emissiveFactor[1], emissiveFactor[2], LinearSRGBColorSpace);
	        }
	        if (materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial) {
	            pending.push(parser.assignTexture(materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace));
	        }
	        return Promise.all(pending).then(function() {
	            const material = new materialType(materialParams);
	            if (materialDef.name) material.name = materialDef.name;
	            assignExtrasToUserData(material, materialDef);
	            parser.associations.set(material, {
	                materials: materialIndex
	            });
	            if (materialDef.extensions) addUnknownExtensionsToUserData(extensions, material, materialDef);
	            return material;
	        });
	    }
	    /**
		 * When Object3D instances are targeted by animation, they need unique names.
		 *
		 * @param {string} originalName
		 * @return {string}
		 */ createUniqueName(originalName) {
	        const sanitizedName = PropertyBinding.sanitizeNodeName(originalName || '');
	        if (sanitizedName in this.nodeNamesUsed) {
	            return sanitizedName + '_' + ++this.nodeNamesUsed[sanitizedName];
	        } else {
	            this.nodeNamesUsed[sanitizedName] = 0;
	            return sanitizedName;
	        }
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
		 *
		 * Creates BufferGeometries from primitives.
		 *
		 * @param {Array<GLTF.Primitive>} primitives
		 * @return {Promise<Array<BufferGeometry>>}
		 */ loadGeometries(primitives) {
	        const parser = this;
	        const extensions = this.extensions;
	        const cache = this.primitiveCache;
	        function createDracoPrimitive(primitive) {
	            return extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(primitive, parser).then(function(geometry) {
	                return addPrimitiveAttributes(geometry, primitive, parser);
	            });
	        }
	        const pending = [];
	        for(let i = 0, il = primitives.length; i < il; i++){
	            const primitive = primitives[i];
	            const cacheKey = createPrimitiveKey(primitive);
	            // See if we've already created this geometry
	            const cached = cache[cacheKey];
	            if (cached) {
	                // Use the cached geometry if it exists
	                pending.push(cached.promise);
	            } else {
	                let geometryPromise;
	                if (primitive.extensions && primitive.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]) {
	                    // Use DRACO geometry if available
	                    geometryPromise = createDracoPrimitive(primitive);
	                } else {
	                    // Otherwise create a new geometry
	                    geometryPromise = addPrimitiveAttributes(new BufferGeometry(), primitive, parser);
	                }
	                // Cache this geometry
	                cache[cacheKey] = {
	                    primitive: primitive,
	                    promise: geometryPromise
	                };
	                pending.push(geometryPromise);
	            }
	        }
	        return Promise.all(pending);
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
		 * @param {number} meshIndex
		 * @return {Promise<Group|Mesh|SkinnedMesh>}
		 */ loadMesh(meshIndex) {
	        const parser = this;
	        const json = this.json;
	        const extensions = this.extensions;
	        const meshDef = json.meshes[meshIndex];
	        const primitives = meshDef.primitives;
	        const pending = [];
	        for(let i = 0, il = primitives.length; i < il; i++){
	            const material = primitives[i].material === undefined ? createDefaultMaterial(this.cache) : this.getDependency('material', primitives[i].material);
	            pending.push(material);
	        }
	        pending.push(parser.loadGeometries(primitives));
	        return Promise.all(pending).then(function(results) {
	            const materials = results.slice(0, results.length - 1);
	            const geometries = results[results.length - 1];
	            const meshes = [];
	            for(let i = 0, il = geometries.length; i < il; i++){
	                const geometry = geometries[i];
	                const primitive = primitives[i];
	                // 1. create Mesh
	                let mesh;
	                const material = materials[i];
	                if (primitive.mode === WEBGL_CONSTANTS$1.TRIANGLES || primitive.mode === WEBGL_CONSTANTS$1.TRIANGLE_STRIP || primitive.mode === WEBGL_CONSTANTS$1.TRIANGLE_FAN || primitive.mode === undefined) {
	                    // .isSkinnedMesh isn't in glTF spec. See ._markDefs()
	                    mesh = meshDef.isSkinnedMesh === true ? new SkinnedMesh(geometry, material) : new Mesh(geometry, material);
	                    if (mesh.isSkinnedMesh === true) {
	                        // normalize skin weights to fix malformed assets (see #15319)
	                        mesh.normalizeSkinWeights();
	                    }
	                    if (primitive.mode === WEBGL_CONSTANTS$1.TRIANGLE_STRIP) {
	                        mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleStripDrawMode);
	                    } else if (primitive.mode === WEBGL_CONSTANTS$1.TRIANGLE_FAN) {
	                        mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleFanDrawMode);
	                    }
	                } else if (primitive.mode === WEBGL_CONSTANTS$1.LINES) {
	                    mesh = new LineSegments(geometry, material);
	                } else if (primitive.mode === WEBGL_CONSTANTS$1.LINE_STRIP) {
	                    mesh = new Line(geometry, material);
	                } else if (primitive.mode === WEBGL_CONSTANTS$1.LINE_LOOP) {
	                    mesh = new LineLoop(geometry, material);
	                } else if (primitive.mode === WEBGL_CONSTANTS$1.POINTS) {
	                    mesh = new Points(geometry, material);
	                } else {
	                    throw new Error('THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode);
	                }
	                if (Object.keys(mesh.geometry.morphAttributes).length > 0) {
	                    updateMorphTargets(mesh, meshDef);
	                }
	                mesh.name = parser.createUniqueName(meshDef.name || 'mesh_' + meshIndex);
	                assignExtrasToUserData(mesh, meshDef);
	                if (primitive.extensions) addUnknownExtensionsToUserData(extensions, mesh, primitive);
	                parser.assignFinalMaterial(mesh);
	                meshes.push(mesh);
	            }
	            for(let i = 0, il = meshes.length; i < il; i++){
	                parser.associations.set(meshes[i], {
	                    meshes: meshIndex,
	                    primitives: i
	                });
	            }
	            if (meshes.length === 1) {
	                if (meshDef.extensions) addUnknownExtensionsToUserData(extensions, meshes[0], meshDef);
	                return meshes[0];
	            }
	            const group = new Group();
	            if (meshDef.extensions) addUnknownExtensionsToUserData(extensions, group, meshDef);
	            parser.associations.set(group, {
	                meshes: meshIndex
	            });
	            for(let i = 0, il = meshes.length; i < il; i++){
	                group.add(meshes[i]);
	            }
	            return group;
	        });
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
		 * @param {number} cameraIndex
		 * @return {Promise<THREE.Camera>}
		 */ loadCamera(cameraIndex) {
	        let camera;
	        const cameraDef = this.json.cameras[cameraIndex];
	        const params = cameraDef[cameraDef.type];
	        if (!params) {
	            console.warn('THREE.GLTFLoader: Missing camera parameters.');
	            return;
	        }
	        if (cameraDef.type === 'perspective') {
	            camera = new PerspectiveCamera(MathUtils.radToDeg(params.yfov), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6);
	        } else if (cameraDef.type === 'orthographic') {
	            camera = new OrthographicCamera(-params.xmag, params.xmag, params.ymag, -params.ymag, params.znear, params.zfar);
	        }
	        if (cameraDef.name) camera.name = this.createUniqueName(cameraDef.name);
	        assignExtrasToUserData(camera, cameraDef);
	        return Promise.resolve(camera);
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
		 * @param {number} skinIndex
		 * @return {Promise<Skeleton>}
		 */ loadSkin(skinIndex) {
	        const skinDef = this.json.skins[skinIndex];
	        const pending = [];
	        for(let i = 0, il = skinDef.joints.length; i < il; i++){
	            pending.push(this._loadNodeShallow(skinDef.joints[i]));
	        }
	        if (skinDef.inverseBindMatrices !== undefined) {
	            pending.push(this.getDependency('accessor', skinDef.inverseBindMatrices));
	        } else {
	            pending.push(null);
	        }
	        return Promise.all(pending).then(function(results) {
	            const inverseBindMatrices = results.pop();
	            const jointNodes = results;
	            // Note that bones (joint nodes) may or may not be in the
	            // scene graph at this time.
	            const bones = [];
	            const boneInverses = [];
	            for(let i = 0, il = jointNodes.length; i < il; i++){
	                const jointNode = jointNodes[i];
	                if (jointNode) {
	                    bones.push(jointNode);
	                    const mat = new Matrix4();
	                    if (inverseBindMatrices !== null) {
	                        mat.fromArray(inverseBindMatrices.array, i * 16);
	                    }
	                    boneInverses.push(mat);
	                } else {
	                    console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[i]);
	                }
	            }
	            return new Skeleton(bones, boneInverses);
	        });
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
		 * @param {number} animationIndex
		 * @return {Promise<AnimationClip>}
		 */ loadAnimation(animationIndex) {
	        const json = this.json;
	        const parser = this;
	        const animationDef = json.animations[animationIndex];
	        const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
	        const pendingNodes = [];
	        const pendingInputAccessors = [];
	        const pendingOutputAccessors = [];
	        const pendingSamplers = [];
	        const pendingTargets = [];
	        for(let i = 0, il = animationDef.channels.length; i < il; i++){
	            const channel = animationDef.channels[i];
	            const sampler = animationDef.samplers[channel.sampler];
	            const target = channel.target;
	            const name = target.node;
	            const input = animationDef.parameters !== undefined ? animationDef.parameters[sampler.input] : sampler.input;
	            const output = animationDef.parameters !== undefined ? animationDef.parameters[sampler.output] : sampler.output;
	            if (target.node === undefined) continue;
	            pendingNodes.push(this.getDependency('node', name));
	            pendingInputAccessors.push(this.getDependency('accessor', input));
	            pendingOutputAccessors.push(this.getDependency('accessor', output));
	            pendingSamplers.push(sampler);
	            pendingTargets.push(target);
	        }
	        return Promise.all([
	            Promise.all(pendingNodes),
	            Promise.all(pendingInputAccessors),
	            Promise.all(pendingOutputAccessors),
	            Promise.all(pendingSamplers),
	            Promise.all(pendingTargets)
	        ]).then(function(dependencies) {
	            const nodes = dependencies[0];
	            const inputAccessors = dependencies[1];
	            const outputAccessors = dependencies[2];
	            const samplers = dependencies[3];
	            const targets = dependencies[4];
	            const tracks = [];
	            for(let i = 0, il = nodes.length; i < il; i++){
	                const node = nodes[i];
	                const inputAccessor = inputAccessors[i];
	                const outputAccessor = outputAccessors[i];
	                const sampler = samplers[i];
	                const target = targets[i];
	                if (node === undefined) continue;
	                if (node.updateMatrix) {
	                    node.updateMatrix();
	                }
	                const createdTracks = parser._createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target);
	                if (createdTracks) {
	                    for(let k = 0; k < createdTracks.length; k++){
	                        tracks.push(createdTracks[k]);
	                    }
	                }
	            }
	            return new AnimationClip(animationName, undefined, tracks);
	        });
	    }
	    createNodeMesh(nodeIndex) {
	        const json = this.json;
	        const parser = this;
	        const nodeDef = json.nodes[nodeIndex];
	        if (nodeDef.mesh === undefined) return null;
	        return parser.getDependency('mesh', nodeDef.mesh).then(function(mesh) {
	            const node = parser._getNodeRef(parser.meshCache, nodeDef.mesh, mesh);
	            // if weights are provided on the node, override weights on the mesh.
	            if (nodeDef.weights !== undefined) {
	                node.traverse(function(o) {
	                    if (!o.isMesh) return;
	                    for(let i = 0, il = nodeDef.weights.length; i < il; i++){
	                        o.morphTargetInfluences[i] = nodeDef.weights[i];
	                    }
	                });
	            }
	            return node;
	        });
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
		 * @param {number} nodeIndex
		 * @return {Promise<Object3D>}
		 */ loadNode(nodeIndex) {
	        const json = this.json;
	        const parser = this;
	        const nodeDef = json.nodes[nodeIndex];
	        const nodePending = parser._loadNodeShallow(nodeIndex);
	        const childPending = [];
	        const childrenDef = nodeDef.children || [];
	        for(let i = 0, il = childrenDef.length; i < il; i++){
	            childPending.push(parser.getDependency('node', childrenDef[i]));
	        }
	        const skeletonPending = nodeDef.skin === undefined ? Promise.resolve(null) : parser.getDependency('skin', nodeDef.skin);
	        return Promise.all([
	            nodePending,
	            Promise.all(childPending),
	            skeletonPending
	        ]).then(function(results) {
	            const node = results[0];
	            const children = results[1];
	            const skeleton = results[2];
	            if (skeleton !== null) {
	                // This full traverse should be fine because
	                // child glTF nodes have not been added to this node yet.
	                node.traverse(function(mesh) {
	                    if (!mesh.isSkinnedMesh) return;
	                    mesh.bind(skeleton, _identityMatrix);
	                });
	            }
	            for(let i = 0, il = children.length; i < il; i++){
	                node.add(children[i]);
	            }
	            return node;
	        });
	    }
	    // ._loadNodeShallow() parses a single node.
	    // skin and child nodes are created and added in .loadNode() (no '_' prefix).
	    _loadNodeShallow(nodeIndex) {
	        const json = this.json;
	        const extensions = this.extensions;
	        const parser = this;
	        // This method is called from .loadNode() and .loadSkin().
	        // Cache a node to avoid duplication.
	        if (this.nodeCache[nodeIndex] !== undefined) {
	            return this.nodeCache[nodeIndex];
	        }
	        const nodeDef = json.nodes[nodeIndex];
	        // reserve node's name before its dependencies, so the root has the intended name.
	        const nodeName = nodeDef.name ? parser.createUniqueName(nodeDef.name) : '';
	        const pending = [];
	        const meshPromise = parser._invokeOne(function(ext) {
	            return ext.createNodeMesh && ext.createNodeMesh(nodeIndex);
	        });
	        if (meshPromise) {
	            pending.push(meshPromise);
	        }
	        if (nodeDef.camera !== undefined) {
	            pending.push(parser.getDependency('camera', nodeDef.camera).then(function(camera) {
	                return parser._getNodeRef(parser.cameraCache, nodeDef.camera, camera);
	            }));
	        }
	        parser._invokeAll(function(ext) {
	            return ext.createNodeAttachment && ext.createNodeAttachment(nodeIndex);
	        }).forEach(function(promise) {
	            pending.push(promise);
	        });
	        this.nodeCache[nodeIndex] = Promise.all(pending).then(function(objects) {
	            let node;
	            // .isBone isn't in glTF spec. See ._markDefs
	            if (nodeDef.isBone === true) {
	                node = new Bone();
	            } else if (objects.length > 1) {
	                node = new Group();
	            } else if (objects.length === 1) {
	                node = objects[0];
	            } else {
	                node = new Object3D();
	            }
	            if (node !== objects[0]) {
	                for(let i = 0, il = objects.length; i < il; i++){
	                    node.add(objects[i]);
	                }
	            }
	            if (nodeDef.name) {
	                node.userData.name = nodeDef.name;
	                node.name = nodeName;
	            }
	            assignExtrasToUserData(node, nodeDef);
	            if (nodeDef.extensions) addUnknownExtensionsToUserData(extensions, node, nodeDef);
	            if (nodeDef.matrix !== undefined) {
	                const matrix = new Matrix4();
	                matrix.fromArray(nodeDef.matrix);
	                node.applyMatrix4(matrix);
	            } else {
	                if (nodeDef.translation !== undefined) {
	                    node.position.fromArray(nodeDef.translation);
	                }
	                if (nodeDef.rotation !== undefined) {
	                    node.quaternion.fromArray(nodeDef.rotation);
	                }
	                if (nodeDef.scale !== undefined) {
	                    node.scale.fromArray(nodeDef.scale);
	                }
	            }
	            if (!parser.associations.has(node)) {
	                parser.associations.set(node, {});
	            }
	            parser.associations.get(node).nodes = nodeIndex;
	            return node;
	        });
	        return this.nodeCache[nodeIndex];
	    }
	    /**
		 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
		 * @param {number} sceneIndex
		 * @return {Promise<Group>}
		 */ loadScene(sceneIndex) {
	        const extensions = this.extensions;
	        const sceneDef = this.json.scenes[sceneIndex];
	        const parser = this;
	        // Loader returns Group, not Scene.
	        // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
	        const scene = new Group();
	        if (sceneDef.name) scene.name = parser.createUniqueName(sceneDef.name);
	        assignExtrasToUserData(scene, sceneDef);
	        if (sceneDef.extensions) addUnknownExtensionsToUserData(extensions, scene, sceneDef);
	        const nodeIds = sceneDef.nodes || [];
	        const pending = [];
	        for(let i = 0, il = nodeIds.length; i < il; i++){
	            pending.push(parser.getDependency('node', nodeIds[i]));
	        }
	        return Promise.all(pending).then(function(nodes) {
	            for(let i = 0, il = nodes.length; i < il; i++){
	                scene.add(nodes[i]);
	            }
	            // Removes dangling associations, associations that reference a node that
	            // didn't make it into the scene.
	            const reduceAssociations = (node)=>{
	                const reducedAssociations = new Map();
	                for (const [key, value] of parser.associations){
	                    if (key instanceof Material$1 || key instanceof Texture$1) {
	                        reducedAssociations.set(key, value);
	                    }
	                }
	                node.traverse((node)=>{
	                    const mappings = parser.associations.get(node);
	                    if (mappings != null) {
	                        reducedAssociations.set(node, mappings);
	                    }
	                });
	                return reducedAssociations;
	            };
	            parser.associations = reduceAssociations(scene);
	            return scene;
	        });
	    }
	    _createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target) {
	        const tracks = [];
	        const targetName = node.name ? node.name : node.uuid;
	        const targetNames = [];
	        if (PATH_PROPERTIES$1[target.path] === PATH_PROPERTIES$1.weights) {
	            node.traverse(function(object) {
	                if (object.morphTargetInfluences) {
	                    targetNames.push(object.name ? object.name : object.uuid);
	                }
	            });
	        } else {
	            targetNames.push(targetName);
	        }
	        let TypedKeyframeTrack;
	        switch(PATH_PROPERTIES$1[target.path]){
	            case PATH_PROPERTIES$1.weights:
	                TypedKeyframeTrack = NumberKeyframeTrack;
	                break;
	            case PATH_PROPERTIES$1.rotation:
	                TypedKeyframeTrack = QuaternionKeyframeTrack;
	                break;
	            case PATH_PROPERTIES$1.position:
	            case PATH_PROPERTIES$1.scale:
	                TypedKeyframeTrack = VectorKeyframeTrack;
	                break;
	            default:
	                switch(outputAccessor.itemSize){
	                    case 1:
	                        TypedKeyframeTrack = NumberKeyframeTrack;
	                        break;
	                    case 2:
	                    case 3:
	                    default:
	                        TypedKeyframeTrack = VectorKeyframeTrack;
	                        break;
	                }
	                break;
	        }
	        const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[sampler.interpolation] : InterpolateLinear;
	        const outputArray = this._getArrayFromAccessor(outputAccessor);
	        for(let j = 0, jl = targetNames.length; j < jl; j++){
	            const track = new TypedKeyframeTrack(targetNames[j] + '.' + PATH_PROPERTIES$1[target.path], inputAccessor.array, outputArray, interpolation);
	            // Override interpolation with custom factory method.
	            if (sampler.interpolation === 'CUBICSPLINE') {
	                this._createCubicSplineTrackInterpolant(track);
	            }
	            tracks.push(track);
	        }
	        return tracks;
	    }
	    _getArrayFromAccessor(accessor) {
	        let outputArray = accessor.array;
	        if (accessor.normalized) {
	            const scale = getNormalizedComponentScale(outputArray.constructor);
	            const scaled = new Float32Array(outputArray.length);
	            for(let j = 0, jl = outputArray.length; j < jl; j++){
	                scaled[j] = outputArray[j] * scale;
	            }
	            outputArray = scaled;
	        }
	        return outputArray;
	    }
	    _createCubicSplineTrackInterpolant(track) {
	        track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
	            // A CUBICSPLINE keyframe in glTF has three output values for each input value,
	            // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
	            // must be divided by three to get the interpolant's sampleSize argument.
	            const interpolantType = this instanceof QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
	            return new interpolantType(this.times, this.values, this.getValueSize() / 3, result);
	        };
	        // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
	        track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
	    }
	    constructor(json = {}, options = {}){
	        this.json = json;
	        this.extensions = {};
	        this.plugins = {};
	        this.options = options;
	        // loader object cache
	        this.cache = new GLTFRegistry();
	        // associations between Three.js objects and glTF elements
	        this.associations = new Map();
	        // BufferGeometry caching
	        this.primitiveCache = {};
	        // Node cache
	        this.nodeCache = {};
	        // Object3D instance caches
	        this.meshCache = {
	            refs: {},
	            uses: {}
	        };
	        this.cameraCache = {
	            refs: {},
	            uses: {}
	        };
	        this.lightCache = {
	            refs: {},
	            uses: {}
	        };
	        this.sourceCache = {};
	        this.textureCache = {};
	        // Track node names, to ensure no duplicates
	        this.nodeNamesUsed = {};
	        // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
	        // expensive work of uploading a texture to the GPU off the main thread.
	        let isSafari = false;
	        let safariVersion = -1;
	        let isFirefox = false;
	        let firefoxVersion = -1;
	        if (typeof navigator !== 'undefined') {
	            const userAgent = navigator.userAgent;
	            isSafari = /^((?!chrome|android).)*safari/i.test(userAgent) === true;
	            const safariMatch = userAgent.match(/Version\/(\d+)/);
	            safariVersion = isSafari && safariMatch ? parseInt(safariMatch[1], 10) : -1;
	            isFirefox = userAgent.indexOf('Firefox') > -1;
	            firefoxVersion = isFirefox ? userAgent.match(/Firefox\/([0-9]+)\./)[1] : -1;
	        }
	        if (typeof createImageBitmap === 'undefined' || isSafari && safariVersion < 17 || isFirefox && firefoxVersion < 98) {
	            this.textureLoader = new TextureLoader(this.options.manager);
	        } else {
	            this.textureLoader = new ImageBitmapLoader(this.options.manager);
	        }
	        this.textureLoader.setCrossOrigin(this.options.crossOrigin);
	        this.textureLoader.setRequestHeader(this.options.requestHeader);
	        this.fileLoader = new FileLoader(this.options.manager);
	        this.fileLoader.setResponseType('arraybuffer');
	        if (this.options.crossOrigin === 'use-credentials') {
	            this.fileLoader.setWithCredentials(true);
	        }
	    }
	}
	/**
	 * @param {BufferGeometry} geometry
	 * @param {GLTF.Primitive} primitiveDef
	 * @param {GLTFParser} parser
	 */ function computeBounds(geometry, primitiveDef, parser) {
	    const attributes = primitiveDef.attributes;
	    const box = new Box3();
	    if (attributes.POSITION !== undefined) {
	        const accessor = parser.json.accessors[attributes.POSITION];
	        const min = accessor.min;
	        const max = accessor.max;
	        // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
	        if (min !== undefined && max !== undefined) {
	            box.set(new Vector3(min[0], min[1], min[2]), new Vector3(max[0], max[1], max[2]));
	            if (accessor.normalized) {
	                const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]);
	                box.min.multiplyScalar(boxScale);
	                box.max.multiplyScalar(boxScale);
	            }
	        } else {
	            console.warn('THREE.GLTFLoader: Missing min/max properties for accessor POSITION.');
	            return;
	        }
	    } else {
	        return;
	    }
	    const targets = primitiveDef.targets;
	    if (targets !== undefined) {
	        const maxDisplacement = new Vector3();
	        const vector = new Vector3();
	        for(let i = 0, il = targets.length; i < il; i++){
	            const target = targets[i];
	            if (target.POSITION !== undefined) {
	                const accessor = parser.json.accessors[target.POSITION];
	                const min = accessor.min;
	                const max = accessor.max;
	                // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
	                if (min !== undefined && max !== undefined) {
	                    // we need to get max of absolute components because target weight is [-1,1]
	                    vector.setX(Math.max(Math.abs(min[0]), Math.abs(max[0])));
	                    vector.setY(Math.max(Math.abs(min[1]), Math.abs(max[1])));
	                    vector.setZ(Math.max(Math.abs(min[2]), Math.abs(max[2])));
	                    if (accessor.normalized) {
	                        const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]);
	                        vector.multiplyScalar(boxScale);
	                    }
	                    // Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative
	                    // to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets
	                    // are used to implement key-frame animations and as such only two are active at a time - this results in very large
	                    // boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.
	                    maxDisplacement.max(vector);
	                } else {
	                    console.warn('THREE.GLTFLoader: Missing min/max properties for accessor POSITION.');
	                }
	            }
	        }
	        // As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
	        box.expandByVector(maxDisplacement);
	    }
	    geometry.boundingBox = box;
	    const sphere = new Sphere();
	    box.getCenter(sphere.center);
	    sphere.radius = box.min.distanceTo(box.max) / 2;
	    geometry.boundingSphere = sphere;
	}
	/**
	 * @param {BufferGeometry} geometry
	 * @param {GLTF.Primitive} primitiveDef
	 * @param {GLTFParser} parser
	 * @return {Promise<BufferGeometry>}
	 */ function addPrimitiveAttributes(geometry, primitiveDef, parser) {
	    const attributes = primitiveDef.attributes;
	    const pending = [];
	    function assignAttributeAccessor(accessorIndex, attributeName) {
	        return parser.getDependency('accessor', accessorIndex).then(function(accessor) {
	            geometry.setAttribute(attributeName, accessor);
	        });
	    }
	    for(const gltfAttributeName in attributes){
	        const threeAttributeName = ATTRIBUTES[gltfAttributeName] || gltfAttributeName.toLowerCase();
	        // Skip attributes already provided by e.g. Draco extension.
	        if (threeAttributeName in geometry.attributes) continue;
	        pending.push(assignAttributeAccessor(attributes[gltfAttributeName], threeAttributeName));
	    }
	    if (primitiveDef.indices !== undefined && !geometry.index) {
	        const accessor = parser.getDependency('accessor', primitiveDef.indices).then(function(accessor) {
	            geometry.setIndex(accessor);
	        });
	        pending.push(accessor);
	    }
	    if (ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes) {
	        console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.`);
	    }
	    assignExtrasToUserData(geometry, primitiveDef);
	    computeBounds(geometry, primitiveDef, parser);
	    return Promise.all(pending).then(function() {
	        return primitiveDef.targets !== undefined ? addMorphTargets(geometry, primitiveDef.targets, parser) : geometry;
	    });
	}

	/**
	 * @author Deepkolos / https://github.com/deepkolos
	 */ class WorkerPool {
	    _initWorker(workerId) {
	        if (!this.workers[workerId]) {
	            const worker = this.workerCreator();
	            worker.addEventListener('message', this._onMessage.bind(this, workerId));
	            this.workers[workerId] = worker;
	        }
	    }
	    _getIdleWorker() {
	        for(let i = 0; i < this.pool; i++)if (!(this.workerStatus & 1 << i)) return i;
	        return -1;
	    }
	    _onMessage(workerId, msg) {
	        const resolve = this.workersResolve[workerId];
	        resolve && resolve(msg);
	        if (this.queue.length) {
	            const { resolve, msg, transfer } = this.queue.shift();
	            this.workersResolve[workerId] = resolve;
	            this.workers[workerId].postMessage(msg, transfer);
	        } else {
	            this.workerStatus ^= 1 << workerId;
	        }
	    }
	    setWorkerCreator(workerCreator) {
	        this.workerCreator = workerCreator;
	    }
	    setWorkerLimit(pool) {
	        this.pool = pool;
	    }
	    postMessage(msg, transfer) {
	        return new Promise((resolve)=>{
	            const workerId = this._getIdleWorker();
	            if (workerId !== -1) {
	                this._initWorker(workerId);
	                this.workerStatus |= 1 << workerId;
	                this.workersResolve[workerId] = resolve;
	                this.workers[workerId].postMessage(msg, transfer);
	            } else {
	                this.queue.push({
	                    resolve,
	                    msg,
	                    transfer
	                });
	            }
	        });
	    }
	    dispose() {
	        this.workers.forEach((worker)=>worker.terminate());
	        this.workersResolve.length = 0;
	        this.workers.length = 0;
	        this.queue.length = 0;
	        this.workerStatus = 0;
	    }
	    constructor(pool = 4){
	        this.pool = pool;
	        this.queue = [];
	        this.workers = [];
	        this.workersResolve = [];
	        this.workerStatus = 0;
	    }
	}

	const t = 0, n = 2, g$1 = 1, u = 2, T = 0, C$1 = 1, R = 10, it = 0, ct = 9, yt = 15, xt = 16, wt = 22, Ft = 37, Ct = 43, te$1 = 76, ae = 83, ge = 97, ue = 100, we = 103, Ae = 109, In = 165, Sn = 166, pi = 1000066e3;
	class Ii {
	    constructor(){
	        this.vkFormat = 0, this.typeSize = 1, this.pixelWidth = 0, this.pixelHeight = 0, this.pixelDepth = 0, this.layerCount = 0, this.faceCount = 1, this.supercompressionScheme = 0, this.levels = [], this.dataFormatDescriptor = [
	            {
	                vendorId: 0,
	                descriptorType: 0,
	                descriptorBlockSize: 0,
	                versionNumber: 2,
	                colorModel: 0,
	                colorPrimaries: 1,
	                transferFunction: 2,
	                flags: 0,
	                texelBlockDimension: [
	                    0,
	                    0,
	                    0,
	                    0
	                ],
	                bytesPlane: [
	                    0,
	                    0,
	                    0,
	                    0,
	                    0,
	                    0,
	                    0,
	                    0
	                ],
	                samples: []
	            }
	        ], this.keyValue = {}, this.globalData = null;
	    }
	}
	class Si {
	    _nextUint8() {
	        const t = this._dataView.getUint8(this._offset);
	        return this._offset += 1, t;
	    }
	    _nextUint16() {
	        const t = this._dataView.getUint16(this._offset, this._littleEndian);
	        return this._offset += 2, t;
	    }
	    _nextUint32() {
	        const t = this._dataView.getUint32(this._offset, this._littleEndian);
	        return this._offset += 4, t;
	    }
	    _nextUint64() {
	        const t = this._dataView.getUint32(this._offset, this._littleEndian) + 2 ** 32 * this._dataView.getUint32(this._offset + 4, this._littleEndian);
	        return this._offset += 8, t;
	    }
	    _nextInt32() {
	        const t = this._dataView.getInt32(this._offset, this._littleEndian);
	        return this._offset += 4, t;
	    }
	    _nextUint8Array(t) {
	        const e = new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + this._offset, t);
	        return this._offset += t, e;
	    }
	    _skip(t) {
	        return this._offset += t, this;
	    }
	    _scan(t, e) {
	        void 0 === e && (e = 0);
	        const n = this._offset;
	        let i = 0;
	        for(; this._dataView.getUint8(this._offset) !== e && i < t;)i++, this._offset++;
	        return i < t && this._offset++, new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + n, i);
	    }
	    constructor(t, e, n, i){
	        this._dataView = void 0, this._littleEndian = void 0, this._offset = void 0, this._dataView = new DataView(t.buffer, t.byteOffset + e, n), this._littleEndian = i, this._offset = 0;
	    }
	}
	const Oi = [
	    171,
	    75,
	    84,
	    88,
	    32,
	    50,
	    48,
	    187,
	    13,
	    10,
	    26,
	    10
	];
	function Ti(t) {
	    return (new TextDecoder).decode(t);
	}
	function Pi(t) {
	    const e = new Uint8Array(t.buffer, t.byteOffset, Oi.length);
	    if (e[0] !== Oi[0] || e[1] !== Oi[1] || e[2] !== Oi[2] || e[3] !== Oi[3] || e[4] !== Oi[4] || e[5] !== Oi[5] || e[6] !== Oi[6] || e[7] !== Oi[7] || e[8] !== Oi[8] || e[9] !== Oi[9] || e[10] !== Oi[10] || e[11] !== Oi[11]) throw new Error("Missing KTX 2.0 identifier.");
	    const n = new Ii, i = 17 * Uint32Array.BYTES_PER_ELEMENT, s = new Si(t, Oi.length, i, true);
	    n.vkFormat = s._nextUint32(), n.typeSize = s._nextUint32(), n.pixelWidth = s._nextUint32(), n.pixelHeight = s._nextUint32(), n.pixelDepth = s._nextUint32(), n.layerCount = s._nextUint32(), n.faceCount = s._nextUint32();
	    const a = s._nextUint32();
	    n.supercompressionScheme = s._nextUint32();
	    const r = s._nextUint32(), o = s._nextUint32(), l = s._nextUint32(), f = s._nextUint32(), h = s._nextUint64(), U = s._nextUint64(), c = new Si(t, Oi.length + i, 3 * a * 8, true);
	    for(let e = 0; e < a; e++)n.levels.push({
	        levelData: new Uint8Array(t.buffer, t.byteOffset + c._nextUint64(), c._nextUint64()),
	        uncompressedByteLength: c._nextUint64()
	    });
	    const _ = new Si(t, r, o, true), p = {
	        vendorId: _._skip(4)._nextUint16(),
	        descriptorType: _._nextUint16(),
	        versionNumber: _._nextUint16(),
	        descriptorBlockSize: _._nextUint16(),
	        colorModel: _._nextUint8(),
	        colorPrimaries: _._nextUint8(),
	        transferFunction: _._nextUint8(),
	        flags: _._nextUint8(),
	        texelBlockDimension: [
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8()
	        ],
	        bytesPlane: [
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8(),
	            _._nextUint8()
	        ],
	        samples: []
	    }, g = (p.descriptorBlockSize / 4 - 6) / 4;
	    for(let t = 0; t < g; t++){
	        const e = {
	            bitOffset: _._nextUint16(),
	            bitLength: _._nextUint8(),
	            channelType: _._nextUint8(),
	            samplePosition: [
	                _._nextUint8(),
	                _._nextUint8(),
	                _._nextUint8(),
	                _._nextUint8()
	            ],
	            sampleLower: -Infinity,
	            sampleUpper: Infinity
	        };
	        64 & e.channelType ? (e.sampleLower = _._nextInt32(), e.sampleUpper = _._nextInt32()) : (e.sampleLower = _._nextUint32(), e.sampleUpper = _._nextUint32()), p.samples[t] = e;
	    }
	    n.dataFormatDescriptor.length = 0, n.dataFormatDescriptor.push(p);
	    const y = new Si(t, l, f, true);
	    for(; y._offset < f;){
	        const t = y._nextUint32(), e = y._scan(t), i = Ti(e);
	        if (n.keyValue[i] = y._nextUint8Array(t - e.byteLength - 1), i.match(/^ktx/i)) {
	            const t = Ti(n.keyValue[i]);
	            n.keyValue[i] = t.substring(0, t.lastIndexOf("\0"));
	        }
	        y._skip(t % 4 ? 4 - t % 4 : 0);
	    }
	    if (U <= 0) return n;
	    const x = new Si(t, h, U, true), u = x._nextUint16(), b = x._nextUint16(), d = x._nextUint32(), w = x._nextUint32(), m = x._nextUint32(), D = x._nextUint32(), B = [];
	    for(let t = 0; t < a; t++)B.push({
	        imageFlags: x._nextUint32(),
	        rgbSliceByteOffset: x._nextUint32(),
	        rgbSliceByteLength: x._nextUint32(),
	        alphaSliceByteOffset: x._nextUint32(),
	        alphaSliceByteLength: x._nextUint32()
	    });
	    const L = h + x._offset, v = L + d, A = v + w, k = A + m, V = new Uint8Array(t.buffer, t.byteOffset + L, d), I = new Uint8Array(t.buffer, t.byteOffset + v, w), S = new Uint8Array(t.buffer, t.byteOffset + A, m), F = new Uint8Array(t.buffer, t.byteOffset + k, D);
	    return n.globalData = {
	        endpointCount: u,
	        selectorCount: b,
	        imageDescs: B,
	        endpointsData: V,
	        selectorsData: I,
	        tablesData: S,
	        extendedData: F
	    }, n;
	}

	let A, I, B;
	const g = {
	    env: {
	        emscripten_notify_memory_growth: function(A) {
	            B = new Uint8Array(I.exports.memory.buffer);
	        }
	    }
	};
	class Q {
	    init() {
	        return A || (A = "undefined" != typeof fetch ? fetch("data:application/wasm;base64," + C).then((A)=>A.arrayBuffer()).then((A)=>WebAssembly.instantiate(A, g)).then(this._init) : WebAssembly.instantiate(Buffer.from(C, "base64"), g).then(this._init), A);
	    }
	    _init(A) {
	        I = A.instance, g.env.emscripten_notify_memory_growth(0);
	    }
	    decode(A, g = 0) {
	        if (!I) throw new Error("ZSTDDecoder: Await .init() before decoding.");
	        const Q = A.byteLength, C = I.exports.malloc(Q);
	        B.set(A, C), g = g || Number(I.exports.ZSTD_findDecompressedSize(C, Q));
	        const E = I.exports.malloc(g), i = I.exports.ZSTD_decompress(E, g, C, Q), D = B.slice(E, E + i);
	        return I.exports.free(C), I.exports.free(E), D;
	    }
	}
	const C = " ";

	const DisplayP3ColorSpace = 'display-p3';
	const LinearDisplayP3ColorSpace = 'display-p3-linear';

	const _taskCache = new WeakMap();
	let _activeLoaders = 0;
	let _zstd;
	class KTX2Loader extends Loader {
	    setTranscoderPath(path) {
	        this.transcoderPath = path;
	        return this;
	    }
	    setWorkerLimit(num) {
	        this.workerPool.setWorkerLimit(num);
	        return this;
	    }
	    async detectSupportAsync(renderer) {
	        this.workerConfig = {
	            astcSupported: await renderer.hasFeatureAsync('texture-compression-astc'),
	            astcHDRSupported: false,
	            etc1Supported: await renderer.hasFeatureAsync('texture-compression-etc1'),
	            etc2Supported: await renderer.hasFeatureAsync('texture-compression-etc2'),
	            dxtSupported: await renderer.hasFeatureAsync('texture-compression-bc'),
	            bptcSupported: await renderer.hasFeatureAsync('texture-compression-bptc'),
	            pvrtcSupported: await renderer.hasFeatureAsync('texture-compression-pvrtc')
	        };
	        return this;
	    }
	    detectSupport(renderer) {
	        if (renderer.isWebGPURenderer === true) {
	            this.workerConfig = {
	                astcSupported: renderer.hasFeature('texture-compression-astc'),
	                astcHDRSupported: false,
	                etc1Supported: renderer.hasFeature('texture-compression-etc1'),
	                etc2Supported: renderer.hasFeature('texture-compression-etc2'),
	                dxtSupported: renderer.hasFeature('texture-compression-bc'),
	                bptcSupported: renderer.hasFeature('texture-compression-bptc'),
	                pvrtcSupported: renderer.hasFeature('texture-compression-pvrtc')
	            };
	        } else {
	            this.workerConfig = {
	                astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
	                astcHDRSupported: renderer.extensions.has('WEBGL_compressed_texture_astc') && renderer.extensions.get('WEBGL_compressed_texture_astc').getSupportedProfiles().includes('hdr'),
	                etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
	                etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
	                dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
	                bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
	                pvrtcSupported: renderer.extensions.has('WEBGL_compressed_texture_pvrtc') || renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc')
	            };
	        }
	        return this;
	    }
	    init() {
	        if (!this.transcoderPending) {
	            // Load transcoder wrapper.
	            const jsLoader = new FileLoader(this.manager);
	            jsLoader.setPath(this.transcoderPath);
	            jsLoader.setWithCredentials(this.withCredentials);
	            const jsContent = jsLoader.loadAsync('basis_transcoder.js');
	            // Load transcoder WASM binary.
	            const binaryLoader = new FileLoader(this.manager);
	            binaryLoader.setPath(this.transcoderPath);
	            binaryLoader.setResponseType('arraybuffer');
	            binaryLoader.setWithCredentials(this.withCredentials);
	            const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm');
	            this.transcoderPending = Promise.all([
	                jsContent,
	                binaryContent
	            ]).then(([jsContent, binaryContent])=>{
	                const fn = KTX2Loader.BasisWorker.toString();
	                const body = [
	                    '/* constants */',
	                    'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat),
	                    'let _EngineType = ' + JSON.stringify(KTX2Loader.EngineType),
	                    'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat),
	                    'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat),
	                    '/* basis_transcoder.js */',
	                    jsContent,
	                    '/* worker */',
	                    fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))
	                ].join('\n');
	                this.workerSourceURL = URL.createObjectURL(new Blob([
	                    body
	                ]));
	                this.transcoderBinary = binaryContent;
	                this.workerPool.setWorkerCreator(()=>{
	                    const worker = new Worker(this.workerSourceURL);
	                    const transcoderBinary = this.transcoderBinary.slice(0);
	                    worker.postMessage({
	                        type: 'init',
	                        config: this.workerConfig,
	                        transcoderBinary
	                    }, [
	                        transcoderBinary
	                    ]);
	                    return worker;
	                });
	            });
	            if (_activeLoaders > 0) {
	                // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
	                console.warn('THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' + ' Use a single KTX2Loader instance, or call .dispose() on old instances.');
	            }
	            _activeLoaders++;
	        }
	        return this.transcoderPending;
	    }
	    load(url, onLoad, onProgress, onError) {
	        if (this.workerConfig === null) {
	            throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.');
	        }
	        const loader = new FileLoader(this.manager);
	        loader.setResponseType('arraybuffer');
	        loader.setWithCredentials(this.withCredentials);
	        loader.load(url, (buffer)=>{
	            this.parse(buffer, onLoad, onError);
	        }, onProgress, onError);
	    }
	    parse(buffer, onLoad, onError) {
	        if (this.workerConfig === null) {
	            throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.');
	        }
	        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
	        // again from this thread.
	        if (_taskCache.has(buffer)) {
	            const cachedTask = _taskCache.get(buffer);
	            return cachedTask.promise.then(onLoad).catch(onError);
	        }
	        this._createTexture(buffer).then((texture)=>onLoad ? onLoad(texture) : null).catch(onError);
	    }
	    _createTextureFrom(transcodeResult, container) {
	        const { type: messageType, error, data: { faces, width, height, format, type, dfdFlags } } = transcodeResult;
	        if (messageType === 'error') return Promise.reject(error);
	        let texture;
	        if (container.faceCount === 6) {
	            texture = new CompressedCubeTexture(faces, format, type);
	        } else {
	            const mipmaps = faces[0].mipmaps;
	            texture = container.layerCount > 1 ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, type) : new CompressedTexture(mipmaps, width, height, format, type);
	        }
	        texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter;
	        texture.magFilter = LinearFilter;
	        texture.generateMipmaps = false;
	        texture.needsUpdate = true;
	        texture.colorSpace = parseColorSpace(container);
	        texture.premultiplyAlpha = !!(dfdFlags & g$1);
	        return texture;
	    }
	    /**
		 * @param {ArrayBuffer} buffer
		 * @param {?Object} config
		 * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
		 */ async _createTexture(buffer, config = {}) {
	        const container = Pi(new Uint8Array(buffer));
	        // Basis UASTC HDR is a subset of ASTC, which can be transcoded efficiently
	        // to BC6H. To detect whether a KTX2 file uses Basis UASTC HDR, or default
	        // ASTC, inspect the DFD color model.
	        //
	        // Source: https://github.com/BinomialLLC/basis_universal/issues/381
	        const isBasisHDR = container.vkFormat === pi && container.dataFormatDescriptor[0].colorModel === 0xA7;
	        // If the device supports ASTC, Basis UASTC HDR requires no transcoder.
	        const needsTranscoder = container.vkFormat === it || isBasisHDR && !this.workerConfig.astcHDRSupported;
	        if (!needsTranscoder) {
	            return createRawTexture(container);
	        }
	        //
	        const taskConfig = config;
	        const texturePending = this.init().then(()=>{
	            return this.workerPool.postMessage({
	                type: 'transcode',
	                buffer,
	                taskConfig: taskConfig
	            }, [
	                buffer
	            ]);
	        }).then((e)=>this._createTextureFrom(e.data, container));
	        // Cache the task result.
	        _taskCache.set(buffer, {
	            promise: texturePending
	        });
	        return texturePending;
	    }
	    dispose() {
	        this.workerPool.dispose();
	        if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL);
	        _activeLoaders--;
	        return this;
	    }
	    constructor(manager){
	        super(manager);
	        this.transcoderPath = '';
	        this.transcoderBinary = null;
	        this.transcoderPending = null;
	        this.workerPool = new WorkerPool();
	        this.workerSourceURL = '';
	        this.workerConfig = null;
	        if (typeof MSC_TRANSCODER !== 'undefined') {
	            console.warn('THREE.KTX2Loader: Please update to latest "basis_transcoder".' + ' "msc_basis_transcoder" is no longer supported in three.js r125+.');
	        }
	    }
	}
	/* CONSTANTS */ KTX2Loader.BasisFormat = {
	    ETC1S: 0,
	    UASTC: 1,
	    UASTC_HDR: 2
	};
	// Source: https://github.com/BinomialLLC/basis_universal/blob/master/webgl/texture_test/index.html
	KTX2Loader.TranscoderFormat = {
	    ETC1: 0,
	    ETC2: 1,
	    BC1: 2,
	    BC3: 3,
	    BC4: 4,
	    BC5: 5,
	    BC7_M6_OPAQUE_ONLY: 6,
	    BC7_M5: 7,
	    PVRTC1_4_RGB: 8,
	    PVRTC1_4_RGBA: 9,
	    ASTC_4x4: 10,
	    ATC_RGB: 11,
	    ATC_RGBA_INTERPOLATED_ALPHA: 12,
	    RGBA32: 13,
	    RGB565: 14,
	    BGR565: 15,
	    RGBA4444: 16,
	    BC6H: 22,
	    RGB_HALF: 24,
	    RGBA_HALF: 25
	};
	KTX2Loader.EngineFormat = {
	    RGBAFormat: RGBAFormat,
	    RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
	    RGB_BPTC_UNSIGNED_Format: RGB_BPTC_UNSIGNED_Format,
	    RGBA_BPTC_Format: RGBA_BPTC_Format,
	    RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
	    RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
	    RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
	    RGB_ETC1_Format: RGB_ETC1_Format,
	    RGB_ETC2_Format: RGB_ETC2_Format,
	    RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
	    RGBA_S3TC_DXT1_Format: RGBA_S3TC_DXT1_Format
	};
	KTX2Loader.EngineType = {
	    UnsignedByteType: UnsignedByteType,
	    HalfFloatType: HalfFloatType,
	    FloatType: FloatType
	};
	/* WEB WORKER */ KTX2Loader.BasisWorker = function() {
	    let config;
	    let transcoderPending;
	    let BasisModule;
	    const EngineFormat = _EngineFormat; // eslint-disable-line no-undef
	    const EngineType = _EngineType; // eslint-disable-line no-undef
	    const TranscoderFormat = _TranscoderFormat; // eslint-disable-line no-undef
	    const BasisFormat = _BasisFormat; // eslint-disable-line no-undef
	    self.addEventListener('message', function(e) {
	        const message = e.data;
	        switch(message.type){
	            case 'init':
	                config = message.config;
	                init(message.transcoderBinary);
	                break;
	            case 'transcode':
	                transcoderPending.then(()=>{
	                    try {
	                        const { faces, buffers, width, height, hasAlpha, format, type, dfdFlags } = transcode(message.buffer);
	                        self.postMessage({
	                            type: 'transcode',
	                            id: message.id,
	                            data: {
	                                faces,
	                                width,
	                                height,
	                                hasAlpha,
	                                format,
	                                type,
	                                dfdFlags
	                            }
	                        }, buffers);
	                    } catch (error) {
	                        console.error(error);
	                        self.postMessage({
	                            type: 'error',
	                            id: message.id,
	                            error: error.message
	                        });
	                    }
	                });
	                break;
	        }
	    });
	    function init(wasmBinary) {
	        transcoderPending = new Promise((resolve)=>{
	            BasisModule = {
	                wasmBinary,
	                onRuntimeInitialized: resolve
	            };
	            BASIS(BasisModule); // eslint-disable-line no-undef
	        }).then(()=>{
	            BasisModule.initializeBasis();
	            if (BasisModule.KTX2File === undefined) {
	                console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.');
	            }
	        });
	    }
	    function transcode(buffer) {
	        const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer));
	        function cleanup() {
	            ktx2File.close();
	            ktx2File.delete();
	        }
	        if (!ktx2File.isValid()) {
	            cleanup();
	            throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file');
	        }
	        let basisFormat;
	        if (ktx2File.isUASTC()) {
	            basisFormat = BasisFormat.UASTC;
	        } else if (ktx2File.isETC1S()) {
	            basisFormat = BasisFormat.ETC1S;
	        } else if (ktx2File.isHDR()) {
	            basisFormat = BasisFormat.UASTC_HDR;
	        } else {
	            throw new Error('THREE.KTX2Loader: Unknown Basis encoding');
	        }
	        const width = ktx2File.getWidth();
	        const height = ktx2File.getHeight();
	        const layerCount = ktx2File.getLayers() || 1;
	        const levelCount = ktx2File.getLevels();
	        const faceCount = ktx2File.getFaces();
	        const hasAlpha = ktx2File.getHasAlpha();
	        const dfdFlags = ktx2File.getDFDFlags();
	        const { transcoderFormat, engineFormat, engineType } = getTranscoderFormat(basisFormat, width, height, hasAlpha);
	        if (!width || !height || !levelCount) {
	            cleanup();
	            throw new Error('THREE.KTX2Loader:	Invalid texture');
	        }
	        if (!ktx2File.startTranscoding()) {
	            cleanup();
	            throw new Error('THREE.KTX2Loader: .startTranscoding failed');
	        }
	        const faces = [];
	        const buffers = [];
	        for(let face = 0; face < faceCount; face++){
	            const mipmaps = [];
	            for(let mip = 0; mip < levelCount; mip++){
	                const layerMips = [];
	                let mipWidth, mipHeight;
	                for(let layer = 0; layer < layerCount; layer++){
	                    const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face);
	                    if (face === 0 && mip === 0 && layer === 0 && (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)) {
	                        console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.');
	                    }
	                    if (levelCount > 1) {
	                        mipWidth = levelInfo.origWidth;
	                        mipHeight = levelInfo.origHeight;
	                    } else {
	                        // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
	                        // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
	                        // See mrdoob/three.js#25908.
	                        mipWidth = levelInfo.width;
	                        mipHeight = levelInfo.height;
	                    }
	                    let dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat));
	                    const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1);
	                    if (engineType === EngineType.HalfFloatType) {
	                        dst = new Uint16Array(dst.buffer, dst.byteOffset, dst.byteLength / Uint16Array.BYTES_PER_ELEMENT);
	                    }
	                    if (!status) {
	                        cleanup();
	                        throw new Error('THREE.KTX2Loader: .transcodeImage failed.');
	                    }
	                    layerMips.push(dst);
	                }
	                const mipData = concat(layerMips);
	                mipmaps.push({
	                    data: mipData,
	                    width: mipWidth,
	                    height: mipHeight
	                });
	                buffers.push(mipData.buffer);
	            }
	            faces.push({
	                mipmaps,
	                width,
	                height,
	                format: engineFormat,
	                type: engineType
	            });
	        }
	        cleanup();
	        return {
	            faces,
	            buffers,
	            width,
	            height,
	            hasAlpha,
	            dfdFlags,
	            format: engineFormat,
	            type: engineType
	        };
	    }
	    //
	    // Optimal choice of a transcoder target format depends on the Basis format (ETC1S, UASTC, or
	    // UASTC HDR), device capabilities, and texture dimensions. The list below ranks the formats
	    // separately for each format. Currently, priority is assigned based on:
	    //
	    //   high quality > low quality > uncompressed
	    //
	    // Prioritization may be revisited, or exposed for configuration, in the future.
	    //
	    // Reference: https://github.com/KhronosGroup/3D-Formats-Guidelines/blob/main/KTXDeveloperGuide.md
	    const FORMAT_OPTIONS = [
	        {
	            if: 'astcSupported',
	            basisFormat: [
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.ASTC_4x4,
	                TranscoderFormat.ASTC_4x4
	            ],
	            engineFormat: [
	                EngineFormat.RGBA_ASTC_4x4_Format,
	                EngineFormat.RGBA_ASTC_4x4_Format
	            ],
	            engineType: [
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: Infinity,
	            priorityUASTC: 1,
	            needsPowerOfTwo: false
	        },
	        {
	            if: 'bptcSupported',
	            basisFormat: [
	                BasisFormat.ETC1S,
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.BC7_M5,
	                TranscoderFormat.BC7_M5
	            ],
	            engineFormat: [
	                EngineFormat.RGBA_BPTC_Format,
	                EngineFormat.RGBA_BPTC_Format
	            ],
	            engineType: [
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: 3,
	            priorityUASTC: 2,
	            needsPowerOfTwo: false
	        },
	        {
	            if: 'dxtSupported',
	            basisFormat: [
	                BasisFormat.ETC1S,
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.BC1,
	                TranscoderFormat.BC3
	            ],
	            engineFormat: [
	                EngineFormat.RGBA_S3TC_DXT1_Format,
	                EngineFormat.RGBA_S3TC_DXT5_Format
	            ],
	            engineType: [
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: 4,
	            priorityUASTC: 5,
	            needsPowerOfTwo: false
	        },
	        {
	            if: 'etc2Supported',
	            basisFormat: [
	                BasisFormat.ETC1S,
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.ETC1,
	                TranscoderFormat.ETC2
	            ],
	            engineFormat: [
	                EngineFormat.RGB_ETC2_Format,
	                EngineFormat.RGBA_ETC2_EAC_Format
	            ],
	            engineType: [
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: 1,
	            priorityUASTC: 3,
	            needsPowerOfTwo: false
	        },
	        {
	            if: 'etc1Supported',
	            basisFormat: [
	                BasisFormat.ETC1S,
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.ETC1
	            ],
	            engineFormat: [
	                EngineFormat.RGB_ETC1_Format
	            ],
	            engineType: [
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: 2,
	            priorityUASTC: 4,
	            needsPowerOfTwo: false
	        },
	        {
	            if: 'pvrtcSupported',
	            basisFormat: [
	                BasisFormat.ETC1S,
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.PVRTC1_4_RGB,
	                TranscoderFormat.PVRTC1_4_RGBA
	            ],
	            engineFormat: [
	                EngineFormat.RGB_PVRTC_4BPPV1_Format,
	                EngineFormat.RGBA_PVRTC_4BPPV1_Format
	            ],
	            engineType: [
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: 5,
	            priorityUASTC: 6,
	            needsPowerOfTwo: true
	        },
	        {
	            if: 'bptcSupported',
	            basisFormat: [
	                BasisFormat.UASTC_HDR
	            ],
	            transcoderFormat: [
	                TranscoderFormat.BC6H
	            ],
	            engineFormat: [
	                EngineFormat.RGB_BPTC_UNSIGNED_Format
	            ],
	            engineType: [
	                EngineType.HalfFloatType
	            ],
	            priorityHDR: 1,
	            needsPowerOfTwo: false
	        },
	        // Uncompressed fallbacks.
	        {
	            basisFormat: [
	                BasisFormat.ETC1S,
	                BasisFormat.UASTC
	            ],
	            transcoderFormat: [
	                TranscoderFormat.RGBA32,
	                TranscoderFormat.RGBA32
	            ],
	            engineFormat: [
	                EngineFormat.RGBAFormat,
	                EngineFormat.RGBAFormat
	            ],
	            engineType: [
	                EngineType.UnsignedByteType,
	                EngineType.UnsignedByteType
	            ],
	            priorityETC1S: 100,
	            priorityUASTC: 100,
	            needsPowerOfTwo: false
	        },
	        {
	            basisFormat: [
	                BasisFormat.UASTC_HDR
	            ],
	            transcoderFormat: [
	                TranscoderFormat.RGBA_HALF
	            ],
	            engineFormat: [
	                EngineFormat.RGBAFormat
	            ],
	            engineType: [
	                EngineType.HalfFloatType
	            ],
	            priorityHDR: 100,
	            needsPowerOfTwo: false
	        }
	    ];
	    const OPTIONS = {
	        // TODO: For ETC1S we intentionally sort by _UASTC_ priority, preserving
	        // a historical accident shown to avoid performance pitfalls for Linux with
	        // Firefox & AMD GPU (RadeonSI). Further work needed.
	        // See https://github.com/mrdoob/three.js/pull/29730.
	        [BasisFormat.ETC1S]: FORMAT_OPTIONS.filter((opt)=>opt.basisFormat.includes(BasisFormat.ETC1S)).sort((a, b)=>a.priorityUASTC - b.priorityUASTC),
	        [BasisFormat.UASTC]: FORMAT_OPTIONS.filter((opt)=>opt.basisFormat.includes(BasisFormat.UASTC)).sort((a, b)=>a.priorityUASTC - b.priorityUASTC),
	        [BasisFormat.UASTC_HDR]: FORMAT_OPTIONS.filter((opt)=>opt.basisFormat.includes(BasisFormat.UASTC_HDR)).sort((a, b)=>a.priorityHDR - b.priorityHDR)
	    };
	    function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
	        const options = OPTIONS[basisFormat];
	        for(let i = 0; i < options.length; i++){
	            const opt = options[i];
	            if (opt.if && !config[opt.if]) continue;
	            if (!opt.basisFormat.includes(basisFormat)) continue;
	            if (hasAlpha && opt.transcoderFormat.length < 2) continue;
	            if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue;
	            const transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0];
	            const engineFormat = opt.engineFormat[hasAlpha ? 1 : 0];
	            const engineType = opt.engineType[0];
	            return {
	                transcoderFormat,
	                engineFormat,
	                engineType
	            };
	        }
	        throw new Error('THREE.KTX2Loader: Failed to identify transcoding target.');
	    }
	    function isPowerOfTwo(value) {
	        if (value <= 2) return true;
	        return (value & value - 1) === 0 && value !== 0;
	    }
	    /**
		 * Concatenates N byte arrays.
		 *
		 * @param {Uint8Array[]} arrays
		 * @return {Uint8Array}
		 */ function concat(arrays) {
	        if (arrays.length === 1) return arrays[0];
	        let totalByteLength = 0;
	        for(let i = 0; i < arrays.length; i++){
	            const array = arrays[i];
	            totalByteLength += array.byteLength;
	        }
	        const result = new Uint8Array(totalByteLength);
	        let byteOffset = 0;
	        for(let i = 0; i < arrays.length; i++){
	            const array = arrays[i];
	            result.set(array, byteOffset);
	            byteOffset += array.byteLength;
	        }
	        return result;
	    }
	};
	// Parsing for non-Basis textures. These textures may have supercompression
	// like Zstd, but they do not require transcoding.
	const UNCOMPRESSED_FORMATS = new Set([
	    RGBAFormat,
	    RGFormat,
	    RedFormat
	]);
	const FORMAT_MAP = {
	    [Ae]: RGBAFormat,
	    [ge]: RGBAFormat,
	    [Ft]: RGBAFormat,
	    [Ct]: RGBAFormat,
	    [we]: RGFormat,
	    [ae]: RGFormat,
	    [xt]: RGFormat,
	    [wt]: RGFormat,
	    [ue]: RedFormat,
	    [te$1]: RedFormat,
	    [yt]: RedFormat,
	    [ct]: RedFormat,
	    [pi]: RGBA_ASTC_4x4_Format,
	    [Sn]: RGBA_ASTC_6x6_Format,
	    [In]: RGBA_ASTC_6x6_Format
	};
	const TYPE_MAP = {
	    [Ae]: FloatType,
	    [ge]: HalfFloatType,
	    [Ft]: UnsignedByteType,
	    [Ct]: UnsignedByteType,
	    [we]: FloatType,
	    [ae]: HalfFloatType,
	    [xt]: UnsignedByteType,
	    [wt]: UnsignedByteType,
	    [ue]: FloatType,
	    [te$1]: HalfFloatType,
	    [yt]: UnsignedByteType,
	    [ct]: UnsignedByteType,
	    [pi]: HalfFloatType,
	    [Sn]: UnsignedByteType,
	    [In]: UnsignedByteType
	};
	async function createRawTexture(container) {
	    const { vkFormat } = container;
	    if (FORMAT_MAP[vkFormat] === undefined) {
	        throw new Error('THREE.KTX2Loader: Unsupported vkFormat.');
	    }
	    //
	    let zstd;
	    if (container.supercompressionScheme === n) {
	        if (!_zstd) {
	            _zstd = new Promise(async (resolve)=>{
	                const zstd = new Q();
	                await zstd.init();
	                resolve(zstd);
	            });
	        }
	        zstd = await _zstd;
	    }
	    //
	    const mipmaps = [];
	    for(let levelIndex = 0; levelIndex < container.levels.length; levelIndex++){
	        const levelWidth = Math.max(1, container.pixelWidth >> levelIndex);
	        const levelHeight = Math.max(1, container.pixelHeight >> levelIndex);
	        const levelDepth = container.pixelDepth ? Math.max(1, container.pixelDepth >> levelIndex) : 0;
	        const level = container.levels[levelIndex];
	        let levelData;
	        if (container.supercompressionScheme === t) {
	            levelData = level.levelData;
	        } else if (container.supercompressionScheme === n) {
	            levelData = zstd.decode(level.levelData, level.uncompressedByteLength);
	        } else {
	            throw new Error('THREE.KTX2Loader: Unsupported supercompressionScheme.');
	        }
	        let data;
	        if (TYPE_MAP[vkFormat] === FloatType) {
	            data = new Float32Array(levelData.buffer, levelData.byteOffset, levelData.byteLength / Float32Array.BYTES_PER_ELEMENT);
	        } else if (TYPE_MAP[vkFormat] === HalfFloatType) {
	            data = new Uint16Array(levelData.buffer, levelData.byteOffset, levelData.byteLength / Uint16Array.BYTES_PER_ELEMENT);
	        } else {
	            data = levelData;
	        }
	        mipmaps.push({
	            data: data,
	            width: levelWidth,
	            height: levelHeight,
	            depth: levelDepth
	        });
	    }
	    let texture;
	    if (UNCOMPRESSED_FORMATS.has(FORMAT_MAP[vkFormat])) {
	        texture = container.pixelDepth === 0 ? new DataTexture(mipmaps[0].data, container.pixelWidth, container.pixelHeight) : new Data3DTexture(mipmaps[0].data, container.pixelWidth, container.pixelHeight, container.pixelDepth);
	    } else {
	        if (container.pixelDepth > 0) throw new Error('THREE.KTX2Loader: Unsupported pixelDepth.');
	        texture = new CompressedTexture(mipmaps, container.pixelWidth, container.pixelHeight);
	        texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter;
	        texture.magFilter = LinearFilter;
	    }
	    texture.mipmaps = mipmaps;
	    texture.type = TYPE_MAP[vkFormat];
	    texture.format = FORMAT_MAP[vkFormat];
	    texture.colorSpace = parseColorSpace(container);
	    texture.needsUpdate = true;
	    //
	    return Promise.resolve(texture);
	}
	function parseColorSpace(container) {
	    const dfd = container.dataFormatDescriptor[0];
	    if (dfd.colorPrimaries === C$1) {
	        return dfd.transferFunction === u ? SRGBColorSpace : LinearSRGBColorSpace;
	    } else if (dfd.colorPrimaries === R) {
	        return dfd.transferFunction === u ? DisplayP3ColorSpace : LinearDisplayP3ColorSpace;
	    } else if (dfd.colorPrimaries === T) {
	        return NoColorSpace;
	    } else {
	        console.warn(`THREE.KTX2Loader: Unsupported color primaries, "${dfd.colorPrimaries}"`);
	        return NoColorSpace;
	    }
	}

	var _a$9, _b$9;
	const $retainerCount = Symbol('retainerCount');
	const $recentlyUsed = Symbol('recentlyUsed');
	const $evict = Symbol('evict');
	const $evictionThreshold = Symbol('evictionThreshold');
	const $cache = Symbol('cache');
	 class CacheEvictionPolicy {
	 set evictionThreshold(value) {
	        this[$evictionThreshold] = value;
	        this[$evict]();
	    }
	    get evictionThreshold() {
	        return this[$evictionThreshold];
	    }
	 get cache() {
	        return this[$cache];
	    }
	 retainerCount(key) {
	        return this[$retainerCount].get(key) || 0;
	    }
	 reset() {
	        this[$retainerCount].clear();
	        this[$recentlyUsed] = [];
	    }
	 retain(key) {
	        if (!this[$retainerCount].has(key)) {
	            this[$retainerCount].set(key, 0);
	        }
	        this[$retainerCount].set(key, this[$retainerCount].get(key) + 1);
	        const recentlyUsedIndex = this[$recentlyUsed].indexOf(key);
	        if (recentlyUsedIndex !== -1) {
	            this[$recentlyUsed].splice(recentlyUsedIndex, 1);
	        }
	        this[$recentlyUsed].unshift(key);
	        this[$evict]();
	    }
	 release(key) {
	        if (this[$retainerCount].has(key)) {
	            this[$retainerCount].set(key, Math.max(this[$retainerCount].get(key) - 1, 0));
	        }
	        this[$evict]();
	    }
	    [(_a$9 = $retainerCount, _b$9 = $recentlyUsed, $evict)]() {
	        if (this[$recentlyUsed].length < this[$evictionThreshold]) {
	            return;
	        }
	        for(let i = this[$recentlyUsed].length - 1; i >= this[$evictionThreshold]; --i){
	            const key = this[$recentlyUsed][i];
	            const retainerCount = this[$retainerCount].get(key);
	            if (retainerCount === 0) {
	                this[$cache].delete(key);
	                this[$recentlyUsed].splice(i, 1);
	            }
	        }
	    }
	    constructor(cache, evictionThreshold = 5){
	        this[_a$9] = new Map();
	        this[_b$9] = [];
	        this[$cache] = cache;
	        this[$evictionThreshold] = evictionThreshold;
	    }
	}

	const ensureUniqueNames = (variantNames)=>{
	    const uniqueNames = [];
	    const knownNames = new Set();
	    for (const name of variantNames){
	        let uniqueName = name;
	        let suffix = 0;
	        while(knownNames.has(uniqueName)){
	            uniqueName = name + '.' + ++suffix;
	        }
	        knownNames.add(uniqueName);
	        uniqueNames.push(uniqueName);
	    }
	    return uniqueNames;
	};
	 const mappingsArrayToTable = (extensionDef)=>{
	    const table = new Map();
	    for (const mapping of extensionDef.mappings){
	        for (const variant of mapping.variants){
	            table.set(variant, {
	                material: null,
	                gltfMaterialIndex: mapping.material
	            });
	        }
	    }
	    return table;
	};
	class GLTFMaterialsVariantsExtension {
	    afterRoot(gltf) {
	        const parser = this.parser;
	        const json = parser.json;
	        if (json.extensions === undefined || json.extensions[this.name] === undefined) {
	            return null;
	        }
	        const extensionDef = json.extensions[this.name];
	        const variantsDef = extensionDef.variants || [];
	        const variants = ensureUniqueNames(variantsDef.map((v)=>v.name));
	        for (const scene of gltf.scenes){
	            scene.traverse((object)=>{
	                const mesh = object;
	                if (!mesh.material) {
	                    return;
	                }
	                const association = parser.associations.get(mesh);
	                if (association == null || association.meshes == null || association.primitives == null) {
	                    return;
	                }
	                const meshDef = json.meshes[association.meshes];
	                const primitivesDef = meshDef.primitives;
	                const primitiveDef = primitivesDef[association.primitives];
	                const extensionsDef = primitiveDef.extensions;
	                if (!extensionsDef || !extensionsDef[this.name]) {
	                    return;
	                }
	                mesh.userData.variantMaterials = mappingsArrayToTable(extensionsDef[this.name]);
	            });
	        }
	        gltf.userData.variants = variants;
	        return Promise.resolve();
	    }
	    constructor(parser){
	        this.parser = parser;
	        this.name = 'KHR_materials_variants';
	    }
	}

	var _a$8, _b$8;
	Texture$1.DEFAULT_ANISOTROPY = 4;
	 const loadWithLoader = (url, loader, progressCallback = ()=>{})=>{
	    const onProgress = (event)=>{
	        const fraction = event.loaded / event.total;
	        progressCallback(Math.max(0, Math.min(1, isFinite(fraction) ? fraction : 1)));
	    };
	    return new Promise((resolve, reject)=>{
	        loader.load(url, resolve, onProgress, reject);
	    });
	};
	 const fetchScript = (src)=>{
	    return new Promise((resolve, reject)=>{
	        const script = document.createElement('script');
	        document.body.appendChild(script);
	        script.onload = resolve;
	        script.onerror = reject;
	        script.async = true;
	        script.src = src;
	    });
	};
	const cache = new Map();
	const preloaded = new Map();
	let dracoDecoderLocation;
	const dracoLoader = new DRACOLoader();
	let ktx2TranscoderLocation;
	const ktx2Loader = new KTX2Loader();
	let meshoptDecoderLocation;
	let meshoptDecoder;
	const $loader = Symbol('loader');
	const $evictionPolicy = Symbol('evictionPolicy');
	const $GLTFInstance = Symbol('GLTFInstance');
	class CachingGLTFLoader extends EventDispatcher {
	    static setDRACODecoderLocation(url) {
	        dracoDecoderLocation = url;
	        dracoLoader.setDecoderPath(url);
	    }
	    static getDRACODecoderLocation() {
	        return dracoDecoderLocation;
	    }
	    static setKTX2TranscoderLocation(url) {
	        ktx2TranscoderLocation = url;
	        ktx2Loader.setTranscoderPath(url);
	    }
	    static getKTX2TranscoderLocation() {
	        return ktx2TranscoderLocation;
	    }
	    static setMeshoptDecoderLocation(url) {
	        if (meshoptDecoderLocation !== url) {
	            meshoptDecoderLocation = url;
	            meshoptDecoder = fetchScript(url).then(()=>MeshoptDecoder.ready).then(()=>MeshoptDecoder);
	        }
	    }
	    static getMeshoptDecoderLocation() {
	        return meshoptDecoderLocation;
	    }
	    static initializeKTX2Loader(renderer) {
	        ktx2Loader.detectSupport(renderer);
	    }
	    static get cache() {
	        return cache;
	    }
	     static clearCache() {
	        cache.forEach((_value, url)=>{
	            this.delete(url);
	        });
	        this[$evictionPolicy].reset();
	    }
	    static has(url) {
	        return cache.has(url);
	    }
	     static async delete(url) {
	        if (!this.has(url)) {
	            return;
	        }
	        const gltfLoads = cache.get(url);
	        preloaded.delete(url);
	        cache.delete(url);
	        const gltf = await gltfLoads;
	        gltf.dispose();
	    }
	 static hasFinishedLoading(url) {
	        return !!preloaded.get(url);
	    }
	    get [(_a$8 = $evictionPolicy, _b$8 = $loader, $evictionPolicy)]() {
	        return this.constructor[$evictionPolicy];
	    }
	 async preload(url, element, progressCallback = ()=>{}) {
	        this[$loader].setWithCredentials(element.withCredentials);
	        this.dispatchEvent({
	            type: 'preload',
	            element: element,
	            src: url
	        });
	        if (!cache.has(url)) {
	            if (meshoptDecoder != null) {
	                this[$loader].setMeshoptDecoder(await meshoptDecoder);
	            }
	            const rawGLTFLoads = loadWithLoader(url, this[$loader], (progress)=>{
	                progressCallback(progress * 0.8);
	            });
	            const GLTFInstance = this[$GLTFInstance];
	            const gltfInstanceLoads = rawGLTFLoads.then((rawGLTF)=>{
	                return GLTFInstance.prepare(rawGLTF);
	            }).then((preparedGLTF)=>{
	                progressCallback(0.9);
	                return new GLTFInstance(preparedGLTF);
	            }).catch((reason)=>{
	                console.error(reason);
	                return new GLTFInstance();
	            });
	            cache.set(url, gltfInstanceLoads);
	        }
	        await cache.get(url);
	        preloaded.set(url, true);
	        if (progressCallback) {
	            progressCallback(1.0);
	        }
	    }
	 async load(url, element, progressCallback = ()=>{}) {
	        await this.preload(url, element, progressCallback);
	        const gltf = await cache.get(url);
	        const clone = await gltf.clone();
	        this[$evictionPolicy].retain(url);
	        clone.dispose = ()=>{
	            this[$evictionPolicy].release(url);
	        };
	        return clone;
	    }
	    constructor(GLTFInstance){
	        super();
	        this[_b$8] = new GLTFLoader().register((parser)=>new GLTFMaterialsVariantsExtension(parser));
	        this[$GLTFInstance] = GLTFInstance;
	        this[$loader].setDRACOLoader(dracoLoader);
	        this[$loader].setKTX2Loader(ktx2Loader);
	    }
	}
	CachingGLTFLoader[_a$8] = new CacheEvictionPolicy(CachingGLTFLoader);

	class CSS2DObject extends Object3D {
	    copy(source, recursive) {
	        super.copy(source, recursive);
	        this.element = source.element.cloneNode(true);
	        this.center = source.center;
	        return this;
	    }
	    constructor(element = document.createElement('div')){
	        super();
	        this.isCSS2DObject = true;
	        this.element = element;
	        this.element.style.position = 'absolute';
	        this.element.style.userSelect = 'none';
	        this.element.setAttribute('draggable', false);
	        this.center = new Vector2(0.5, 0.5); // ( 0, 0 ) is the lower left; ( 1, 1 ) is the top right
	        this.addEventListener('removed', function() {
	            this.traverse(function(object) {
	                if (object.element instanceof object.element.ownerDocument.defaultView.Element && object.element.parentNode !== null) {
	                    object.element.remove();
	                }
	            });
	        });
	    }
	}
	//
	const _vector = new Vector3();
	const _viewMatrix = new Matrix4();
	const _viewProjectionMatrix = new Matrix4();
	const _a$7 = new Vector3();
	const _b$7 = new Vector3();
	class CSS2DRenderer {
	    constructor(parameters = {}){
	        const _this = this;
	        let _width, _height;
	        let _widthHalf, _heightHalf;
	        const cache = {
	            objects: new WeakMap()
	        };
	        const domElement = parameters.element !== undefined ? parameters.element : document.createElement('div');
	        domElement.style.overflow = 'hidden';
	        this.domElement = domElement;
	        this.getSize = function() {
	            return {
	                width: _width,
	                height: _height
	            };
	        };
	        this.render = function(scene, camera) {
	            if (scene.matrixWorldAutoUpdate === true) scene.updateMatrixWorld();
	            if (camera.parent === null && camera.matrixWorldAutoUpdate === true) camera.updateMatrixWorld();
	            _viewMatrix.copy(camera.matrixWorldInverse);
	            _viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, _viewMatrix);
	            renderObject(scene, scene, camera);
	            zOrder(scene);
	        };
	        this.setSize = function(width, height) {
	            _width = width;
	            _height = height;
	            _widthHalf = _width / 2;
	            _heightHalf = _height / 2;
	            domElement.style.width = width + 'px';
	            domElement.style.height = height + 'px';
	        };
	        function hideObject(object) {
	            if (object.isCSS2DObject) object.element.style.display = 'none';
	            for(let i = 0, l = object.children.length; i < l; i++){
	                hideObject(object.children[i]);
	            }
	        }
	        function renderObject(object, scene, camera) {
	            if (object.visible === false) {
	                hideObject(object);
	                return;
	            }
	            if (object.isCSS2DObject) {
	                _vector.setFromMatrixPosition(object.matrixWorld);
	                _vector.applyMatrix4(_viewProjectionMatrix);
	                const visible = _vector.z >= -1 && _vector.z <= 1 && object.layers.test(camera.layers) === true;
	                const element = object.element;
	                element.style.display = visible === true ? '' : 'none';
	                if (visible === true) {
	                    object.onBeforeRender(_this, scene, camera);
	                    element.style.transform = 'translate(' + -100 * object.center.x + '%,' + -100 * object.center.y + '%)' + 'translate(' + (_vector.x * _widthHalf + _widthHalf) + 'px,' + (-_vector.y * _heightHalf + _heightHalf) + 'px)';
	                    if (element.parentNode !== domElement) {
	                        domElement.appendChild(element);
	                    }
	                    object.onAfterRender(_this, scene, camera);
	                }
	                const objectData = {
	                    distanceToCameraSquared: getDistanceToSquared(camera, object)
	                };
	                cache.objects.set(object, objectData);
	            }
	            for(let i = 0, l = object.children.length; i < l; i++){
	                renderObject(object.children[i], scene, camera);
	            }
	        }
	        function getDistanceToSquared(object1, object2) {
	            _a$7.setFromMatrixPosition(object1.matrixWorld);
	            _b$7.setFromMatrixPosition(object2.matrixWorld);
	            return _a$7.distanceToSquared(_b$7);
	        }
	        function filterAndFlatten(scene) {
	            const result = [];
	            scene.traverseVisible(function(object) {
	                if (object.isCSS2DObject) result.push(object);
	            });
	            return result;
	        }
	        function zOrder(scene) {
	            const sorted = filterAndFlatten(scene).sort(function(a, b) {
	                if (a.renderOrder !== b.renderOrder) {
	                    return b.renderOrder - a.renderOrder;
	                }
	                const distanceA = cache.objects.get(a).distanceToCameraSquared;
	                const distanceB = cache.objects.get(b).distanceToCameraSquared;
	                return distanceA - distanceB;
	            });
	            const zMax = sorted.length;
	            for(let i = 0, l = sorted.length; i < l; i++){
	                sorted[i].element.style.zIndex = zMax - i;
	            }
	        }
	    }
	}

	function reduceVertices(object, func, initialValue) {
	    let value = initialValue;
	    const vertex = new Vector3();
	    object.updateWorldMatrix(true, true);
	    object.traverseVisible((child)=>{
	        const { geometry } = child;
	        if (geometry !== undefined) {
	            const { position } = geometry.attributes;
	            if (position !== undefined) {
	                for(let i = 0, l = position.count; i < l; i++){
	                    if (child.isMesh) {
	                        child.getVertexPosition(i, vertex);
	                    } else {
	                        vertex.fromBufferAttribute(position, i);
	                    }
	                    if (!child.isSkinnedMesh) {
	                        vertex.applyMatrix4(child.matrixWorld);
	                    }
	                    value = func(value, vertex);
	                }
	            }
	        }
	    });
	    return value;
	}

	/**
	 * The KHR_mesh_quantization extension allows these extra attribute component types
	 *
	 * @see https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md#extending-mesh-attributes
	 */ const KHR_mesh_quantization_ExtraAttrTypes = {
	    POSITION: [
	        'byte',
	        'byte normalized',
	        'unsigned byte',
	        'unsigned byte normalized',
	        'short',
	        'short normalized',
	        'unsigned short',
	        'unsigned short normalized'
	    ],
	    NORMAL: [
	        'byte normalized',
	        'short normalized'
	    ],
	    TANGENT: [
	        'byte normalized',
	        'short normalized'
	    ],
	    TEXCOORD: [
	        'byte',
	        'byte normalized',
	        'unsigned byte',
	        'short',
	        'short normalized',
	        'unsigned short'
	    ]
	};
	class GLTFExporter {
	    register(callback) {
	        if (this.pluginCallbacks.indexOf(callback) === -1) {
	            this.pluginCallbacks.push(callback);
	        }
	        return this;
	    }
	    unregister(callback) {
	        if (this.pluginCallbacks.indexOf(callback) !== -1) {
	            this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
	        }
	        return this;
	    }
	    setTextureUtils(utils) {
	        this.textureUtils = utils;
	        return this;
	    }
	    /**
		 * Parse scenes and generate GLTF output
		 *
		 * @param  {Scene|Array<Scene>} input   Scene or Array of THREE.Scenes
		 * @param  {Function} onDone  Callback on completed
		 * @param  {Function} onError  Callback on errors
		 * @param  {Object} options options
		 */ parse(input, onDone, onError, options) {
	        const writer = new GLTFWriter();
	        const plugins = [];
	        for(let i = 0, il = this.pluginCallbacks.length; i < il; i++){
	            plugins.push(this.pluginCallbacks[i](writer));
	        }
	        writer.setPlugins(plugins);
	        writer.setTextureUtils(this.textureUtils);
	        writer.writeAsync(input, onDone, options).catch(onError);
	    }
	    parseAsync(input, options) {
	        const scope = this;
	        return new Promise(function(resolve, reject) {
	            scope.parse(input, resolve, reject, options);
	        });
	    }
	    constructor(){
	        this.textureUtils = null;
	        this.pluginCallbacks = [];
	        this.register(function(writer) {
	            return new GLTFLightExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsUnlitExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsTransmissionExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsVolumeExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsIorExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsSpecularExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsClearcoatExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsDispersionExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsIridescenceExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsSheenExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsAnisotropyExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsEmissiveStrengthExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMaterialsBumpExtension(writer);
	        });
	        this.register(function(writer) {
	            return new GLTFMeshGpuInstancing(writer);
	        });
	    }
	}
	//------------------------------------------------------------------------------
	// Constants
	//------------------------------------------------------------------------------
	const WEBGL_CONSTANTS = {
	    POINTS: 0x0000,
	    LINES: 0x0001,
	    LINE_LOOP: 0x0002,
	    LINE_STRIP: 0x0003,
	    TRIANGLES: 0x0004,
	    BYTE: 0x1400,
	    UNSIGNED_BYTE: 0x1401,
	    SHORT: 0x1402,
	    UNSIGNED_SHORT: 0x1403,
	    INT: 0x1404,
	    UNSIGNED_INT: 0x1405,
	    FLOAT: 0x1406,
	    ARRAY_BUFFER: 0x8892,
	    ELEMENT_ARRAY_BUFFER: 0x8893,
	    NEAREST: 0x2600,
	    LINEAR: 0x2601,
	    NEAREST_MIPMAP_NEAREST: 0x2700,
	    LINEAR_MIPMAP_NEAREST: 0x2701,
	    NEAREST_MIPMAP_LINEAR: 0x2702,
	    LINEAR_MIPMAP_LINEAR: 0x2703,
	    CLAMP_TO_EDGE: 33071,
	    MIRRORED_REPEAT: 33648,
	    REPEAT: 10497
	};
	const KHR_MESH_QUANTIZATION = 'KHR_mesh_quantization';
	const THREE_TO_WEBGL = {};
	THREE_TO_WEBGL[NearestFilter] = WEBGL_CONSTANTS.NEAREST;
	THREE_TO_WEBGL[NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
	THREE_TO_WEBGL[NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
	THREE_TO_WEBGL[LinearFilter] = WEBGL_CONSTANTS.LINEAR;
	THREE_TO_WEBGL[LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
	THREE_TO_WEBGL[LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
	THREE_TO_WEBGL[ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
	THREE_TO_WEBGL[RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
	THREE_TO_WEBGL[MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
	const PATH_PROPERTIES = {
	    scale: 'scale',
	    position: 'translation',
	    quaternion: 'rotation',
	    morphTargetInfluences: 'weights'
	};
	const DEFAULT_SPECULAR_COLOR = new Color();
	// GLB constants
	// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
	const GLB_HEADER_BYTES = 12;
	const GLB_HEADER_MAGIC = 0x46546C67;
	const GLB_VERSION = 2;
	const GLB_CHUNK_PREFIX_BYTES = 8;
	const GLB_CHUNK_TYPE_JSON = 0x4E4F534A;
	const GLB_CHUNK_TYPE_BIN = 0x004E4942;
	//------------------------------------------------------------------------------
	// Utility functions
	//------------------------------------------------------------------------------
	/**
	 * Compare two arrays
	 * @param  {Array} array1 Array 1 to compare
	 * @param  {Array} array2 Array 2 to compare
	 * @return {boolean}        Returns true if both arrays are equal
	 */ function equalArray(array1, array2) {
	    return array1.length === array2.length && array1.every(function(element, index) {
	        return element === array2[index];
	    });
	}
	/**
	 * Converts a string to an ArrayBuffer.
	 * @param  {string} text
	 * @return {ArrayBuffer}
	 */ function stringToArrayBuffer(text) {
	    return new TextEncoder().encode(text).buffer;
	}
	/**
	 * Is identity matrix
	 *
	 * @param {Matrix4} matrix
	 * @returns {boolean} Returns true, if parameter is identity matrix
	 */ function isIdentityMatrix(matrix) {
	    return equalArray(matrix.elements, [
	        1,
	        0,
	        0,
	        0,
	        0,
	        1,
	        0,
	        0,
	        0,
	        0,
	        1,
	        0,
	        0,
	        0,
	        0,
	        1
	    ]);
	}
	/**
	 * Get the min and max vectors from the given attribute
	 *
	 * @param  {BufferAttribute} attribute Attribute to find the min/max in range from start to start + count
	 * @param  {number} start Start index
	 * @param  {number} count Range to cover
	 * @return {Object} Object containing the `min` and `max` values (As an array of attribute.itemSize components)
	 */ function getMinMax(attribute, start, count) {
	    const output = {
	        min: new Array(attribute.itemSize).fill(Number.POSITIVE_INFINITY),
	        max: new Array(attribute.itemSize).fill(Number.NEGATIVE_INFINITY)
	    };
	    for(let i = start; i < start + count; i++){
	        for(let a = 0; a < attribute.itemSize; a++){
	            let value;
	            if (attribute.itemSize > 4) {
	                // no support for interleaved data for itemSize > 4
	                value = attribute.array[i * attribute.itemSize + a];
	            } else {
	                if (a === 0) value = attribute.getX(i);
	                else if (a === 1) value = attribute.getY(i);
	                else if (a === 2) value = attribute.getZ(i);
	                else if (a === 3) value = attribute.getW(i);
	                if (attribute.normalized === true) {
	                    value = MathUtils.normalize(value, attribute.array);
	                }
	            }
	            output.min[a] = Math.min(output.min[a], value);
	            output.max[a] = Math.max(output.max[a], value);
	        }
	    }
	    return output;
	}
	/**
	 * Get the required size + padding for a buffer, rounded to the next 4-byte boundary.
	 * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
	 *
	 * @param {number} bufferSize The size the original buffer. Should be an integer.
	 * @returns {number} new buffer size with required padding as an integer.
	 *
	 */ function getPaddedBufferSize(bufferSize) {
	    return Math.ceil(bufferSize / 4) * 4;
	}
	/**
	 * Returns a buffer aligned to 4-byte boundary.
	 *
	 * @param {ArrayBuffer} arrayBuffer Buffer to pad
	 * @param {number} [paddingByte=0] Should be an integer
	 * @returns {ArrayBuffer} The same buffer if it's already aligned to 4-byte boundary or a new buffer
	 */ function getPaddedArrayBuffer(arrayBuffer, paddingByte = 0) {
	    const paddedLength = getPaddedBufferSize(arrayBuffer.byteLength);
	    if (paddedLength !== arrayBuffer.byteLength) {
	        const array = new Uint8Array(paddedLength);
	        array.set(new Uint8Array(arrayBuffer));
	        if (paddingByte !== 0) {
	            for(let i = arrayBuffer.byteLength; i < paddedLength; i++){
	                array[i] = paddingByte;
	            }
	        }
	        return array.buffer;
	    }
	    return arrayBuffer;
	}
	function getCanvas() {
	    if (typeof document === 'undefined' && typeof OffscreenCanvas !== 'undefined') {
	        return new OffscreenCanvas(1, 1);
	    }
	    return document.createElement('canvas');
	}
	function getToBlobPromise(canvas, mimeType) {
	    if (canvas.toBlob !== undefined) {
	        return new Promise((resolve)=>canvas.toBlob(resolve, mimeType));
	    }
	    let quality;
	    // Blink's implementation of convertToBlob seems to default to a quality level of 100%
	    // Use the Blink default quality levels of toBlob instead so that file sizes are comparable.
	    if (mimeType === 'image/jpeg') {
	        quality = 0.92;
	    } else if (mimeType === 'image/webp') {
	        quality = 0.8;
	    }
	    return canvas.convertToBlob({
	        type: mimeType,
	        quality: quality
	    });
	}
	/**
	 * Writer
	 */ class GLTFWriter {
	    setPlugins(plugins) {
	        this.plugins = plugins;
	    }
	    setTextureUtils(utils) {
	        this.textureUtils = utils;
	    }
	    /**
		 * Parse scenes and generate GLTF output
		 *
		 * @param {Scene|Array<Scene>} input Scene or Array of THREE.Scenes
		 * @param {Function} onDone Callback on completed
		 * @param {Object} options options
		 */ async writeAsync(input, onDone, options = {}) {
	        this.options = Object.assign({
	            // default options
	            binary: false,
	            trs: false,
	            onlyVisible: true,
	            maxTextureSize: Infinity,
	            animations: [],
	            includeCustomExtensions: false
	        }, options);
	        if (this.options.animations.length > 0) {
	            // Only TRS properties, and not matrices, may be targeted by animation.
	            this.options.trs = true;
	        }
	        await this.processInputAsync(input);
	        await Promise.all(this.pending);
	        const writer = this;
	        const buffers = writer.buffers;
	        const json = writer.json;
	        options = writer.options;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionsRequired = writer.extensionsRequired;
	        // Merge buffers.
	        const blob = new Blob(buffers, {
	            type: 'application/octet-stream'
	        });
	        // Declare extensions.
	        const extensionsUsedList = Object.keys(extensionsUsed);
	        const extensionsRequiredList = Object.keys(extensionsRequired);
	        if (extensionsUsedList.length > 0) json.extensionsUsed = extensionsUsedList;
	        if (extensionsRequiredList.length > 0) json.extensionsRequired = extensionsRequiredList;
	        // Update bytelength of the single buffer.
	        if (json.buffers && json.buffers.length > 0) json.buffers[0].byteLength = blob.size;
	        if (options.binary === true) {
	            // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
	            const reader = new FileReader();
	            reader.readAsArrayBuffer(blob);
	            reader.onloadend = function() {
	                // Binary chunk.
	                const binaryChunk = getPaddedArrayBuffer(reader.result);
	                const binaryChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
	                binaryChunkPrefix.setUint32(0, binaryChunk.byteLength, true);
	                binaryChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_BIN, true);
	                // JSON chunk.
	                const jsonChunk = getPaddedArrayBuffer(stringToArrayBuffer(JSON.stringify(json)), 0x20);
	                const jsonChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
	                jsonChunkPrefix.setUint32(0, jsonChunk.byteLength, true);
	                jsonChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_JSON, true);
	                // GLB header.
	                const header = new ArrayBuffer(GLB_HEADER_BYTES);
	                const headerView = new DataView(header);
	                headerView.setUint32(0, GLB_HEADER_MAGIC, true);
	                headerView.setUint32(4, GLB_VERSION, true);
	                const totalByteLength = GLB_HEADER_BYTES + jsonChunkPrefix.byteLength + jsonChunk.byteLength + binaryChunkPrefix.byteLength + binaryChunk.byteLength;
	                headerView.setUint32(8, totalByteLength, true);
	                const glbBlob = new Blob([
	                    header,
	                    jsonChunkPrefix,
	                    jsonChunk,
	                    binaryChunkPrefix,
	                    binaryChunk
	                ], {
	                    type: 'application/octet-stream'
	                });
	                const glbReader = new FileReader();
	                glbReader.readAsArrayBuffer(glbBlob);
	                glbReader.onloadend = function() {
	                    onDone(glbReader.result);
	                };
	            };
	        } else {
	            if (json.buffers && json.buffers.length > 0) {
	                const reader = new FileReader();
	                reader.readAsDataURL(blob);
	                reader.onloadend = function() {
	                    const base64data = reader.result;
	                    json.buffers[0].uri = base64data;
	                    onDone(json);
	                };
	            } else {
	                onDone(json);
	            }
	        }
	    }
	    /**
		 * Serializes a userData.
		 *
		 * @param {THREE.Object3D|THREE.Material} object
		 * @param {Object} objectDef
		 */ serializeUserData(object, objectDef) {
	        if (Object.keys(object.userData).length === 0) return;
	        const options = this.options;
	        const extensionsUsed = this.extensionsUsed;
	        try {
	            const json = JSON.parse(JSON.stringify(object.userData));
	            if (options.includeCustomExtensions && json.gltfExtensions) {
	                if (objectDef.extensions === undefined) objectDef.extensions = {};
	                for(const extensionName in json.gltfExtensions){
	                    objectDef.extensions[extensionName] = json.gltfExtensions[extensionName];
	                    extensionsUsed[extensionName] = true;
	                }
	                delete json.gltfExtensions;
	            }
	            if (Object.keys(json).length > 0) objectDef.extras = json;
	        } catch (error) {
	            console.warn('THREE.GLTFExporter: userData of \'' + object.name + '\' ' + 'won\'t be serialized because of JSON.stringify error - ' + error.message);
	        }
	    }
	    /**
		 * Returns ids for buffer attributes.
		 *
		 * @param  {Object} attribute
		 * @param {boolean} [isRelativeCopy=false]
		 * @return {number} An integer
		 */ getUID(attribute, isRelativeCopy = false) {
	        if (this.uids.has(attribute) === false) {
	            const uids = new Map();
	            uids.set(true, this.uid++);
	            uids.set(false, this.uid++);
	            this.uids.set(attribute, uids);
	        }
	        const uids = this.uids.get(attribute);
	        return uids.get(isRelativeCopy);
	    }
	    /**
		 * Checks if normal attribute values are normalized.
		 *
		 * @param {BufferAttribute} normal
		 * @returns {boolean}
		 */ isNormalizedNormalAttribute(normal) {
	        const cache = this.cache;
	        if (cache.attributesNormalized.has(normal)) return false;
	        const v = new Vector3();
	        for(let i = 0, il = normal.count; i < il; i++){
	            // 0.0005 is from glTF-validator
	            if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1.0) > 0.0005) return false;
	        }
	        return true;
	    }
	    /**
		 * Creates normalized normal buffer attribute.
		 *
		 * @param {BufferAttribute} normal
		 * @returns {BufferAttribute}
		 *
		 */ createNormalizedNormalAttribute(normal) {
	        const cache = this.cache;
	        if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
	        const attribute = normal.clone();
	        const v = new Vector3();
	        for(let i = 0, il = attribute.count; i < il; i++){
	            v.fromBufferAttribute(attribute, i);
	            if (v.x === 0 && v.y === 0 && v.z === 0) {
	                // if values can't be normalized set (1, 0, 0)
	                v.setX(1.0);
	            } else {
	                v.normalize();
	            }
	            attribute.setXYZ(i, v.x, v.y, v.z);
	        }
	        cache.attributesNormalized.set(normal, attribute);
	        return attribute;
	    }
	    /**
		 * Applies a texture transform, if present, to the map definition. Requires
		 * the KHR_texture_transform extension.
		 *
		 * @param {Object} mapDef
		 * @param {THREE.Texture} texture
		 */ applyTextureTransform(mapDef, texture) {
	        let didTransform = false;
	        const transformDef = {};
	        if (texture.offset.x !== 0 || texture.offset.y !== 0) {
	            transformDef.offset = texture.offset.toArray();
	            didTransform = true;
	        }
	        if (texture.rotation !== 0) {
	            transformDef.rotation = texture.rotation;
	            didTransform = true;
	        }
	        if (texture.repeat.x !== 1 || texture.repeat.y !== 1) {
	            transformDef.scale = texture.repeat.toArray();
	            didTransform = true;
	        }
	        if (didTransform) {
	            mapDef.extensions = mapDef.extensions || {};
	            mapDef.extensions['KHR_texture_transform'] = transformDef;
	            this.extensionsUsed['KHR_texture_transform'] = true;
	        }
	    }
	    async buildMetalRoughTextureAsync(metalnessMap, roughnessMap) {
	        if (metalnessMap === roughnessMap) return metalnessMap;
	        function getEncodingConversion(map) {
	            if (map.colorSpace === SRGBColorSpace) {
	                return function SRGBToLinear(c) {
	                    return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
	                };
	            }
	            return function LinearToLinear(c) {
	                return c;
	            };
	        }
	        if (metalnessMap instanceof CompressedTexture) {
	            metalnessMap = await this.decompressTextureAsync(metalnessMap);
	        }
	        if (roughnessMap instanceof CompressedTexture) {
	            roughnessMap = await this.decompressTextureAsync(roughnessMap);
	        }
	        const metalness = metalnessMap ? metalnessMap.image : null;
	        const roughness = roughnessMap ? roughnessMap.image : null;
	        const width = Math.max(metalness ? metalness.width : 0, roughness ? roughness.width : 0);
	        const height = Math.max(metalness ? metalness.height : 0, roughness ? roughness.height : 0);
	        const canvas = getCanvas();
	        canvas.width = width;
	        canvas.height = height;
	        const context = canvas.getContext('2d', {
	            willReadFrequently: true
	        });
	        context.fillStyle = '#00ffff';
	        context.fillRect(0, 0, width, height);
	        const composite = context.getImageData(0, 0, width, height);
	        if (metalness) {
	            context.drawImage(metalness, 0, 0, width, height);
	            const convert = getEncodingConversion(metalnessMap);
	            const data = context.getImageData(0, 0, width, height).data;
	            for(let i = 2; i < data.length; i += 4){
	                composite.data[i] = convert(data[i] / 256) * 256;
	            }
	        }
	        if (roughness) {
	            context.drawImage(roughness, 0, 0, width, height);
	            const convert = getEncodingConversion(roughnessMap);
	            const data = context.getImageData(0, 0, width, height).data;
	            for(let i = 1; i < data.length; i += 4){
	                composite.data[i] = convert(data[i] / 256) * 256;
	            }
	        }
	        context.putImageData(composite, 0, 0);
	        //
	        const reference = metalnessMap || roughnessMap;
	        const texture = reference.clone();
	        texture.source = new Source(canvas);
	        texture.colorSpace = NoColorSpace;
	        texture.channel = (metalnessMap || roughnessMap).channel;
	        if (metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel) {
	            console.warn('THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.');
	        }
	        console.warn('THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.');
	        return texture;
	    }
	    async decompressTextureAsync(texture, maxTextureSize = Infinity) {
	        if (this.textureUtils === null) {
	            throw new Error('THREE.GLTFExporter: setTextureUtils() must be called to process compressed textures.');
	        }
	        return await this.textureUtils.decompress(texture, maxTextureSize);
	    }
	    /**
		 * Process a buffer to append to the default one.
		 * @param  {ArrayBuffer} buffer
		 * @return {0}
		 */ processBuffer(buffer) {
	        const json = this.json;
	        const buffers = this.buffers;
	        if (!json.buffers) json.buffers = [
	            {
	                byteLength: 0
	            }
	        ];
	        // All buffers are merged before export.
	        buffers.push(buffer);
	        return 0;
	    }
	    /**
		 * Process and generate a BufferView
		 * @param {BufferAttribute} attribute
		 * @param {number} componentType
		 * @param {number} start
		 * @param {number} count
		 * @param {?number} target Target usage of the BufferView
		 * @return {Object}
		 */ processBufferView(attribute, componentType, start, count, target) {
	        const json = this.json;
	        if (!json.bufferViews) json.bufferViews = [];
	        // Create a new dataview and dump the attribute's array into it
	        let componentSize;
	        switch(componentType){
	            case WEBGL_CONSTANTS.BYTE:
	            case WEBGL_CONSTANTS.UNSIGNED_BYTE:
	                componentSize = 1;
	                break;
	            case WEBGL_CONSTANTS.SHORT:
	            case WEBGL_CONSTANTS.UNSIGNED_SHORT:
	                componentSize = 2;
	                break;
	            default:
	                componentSize = 4;
	        }
	        let byteStride = attribute.itemSize * componentSize;
	        if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
	            // Each element of a vertex attribute MUST be aligned to 4-byte boundaries
	            // inside a bufferView
	            byteStride = Math.ceil(byteStride / 4) * 4;
	        }
	        const byteLength = getPaddedBufferSize(count * byteStride);
	        const dataView = new DataView(new ArrayBuffer(byteLength));
	        let offset = 0;
	        for(let i = start; i < start + count; i++){
	            for(let a = 0; a < attribute.itemSize; a++){
	                let value;
	                if (attribute.itemSize > 4) {
	                    // no support for interleaved data for itemSize > 4
	                    value = attribute.array[i * attribute.itemSize + a];
	                } else {
	                    if (a === 0) value = attribute.getX(i);
	                    else if (a === 1) value = attribute.getY(i);
	                    else if (a === 2) value = attribute.getZ(i);
	                    else if (a === 3) value = attribute.getW(i);
	                    if (attribute.normalized === true) {
	                        value = MathUtils.normalize(value, attribute.array);
	                    }
	                }
	                if (componentType === WEBGL_CONSTANTS.FLOAT) {
	                    dataView.setFloat32(offset, value, true);
	                } else if (componentType === WEBGL_CONSTANTS.INT) {
	                    dataView.setInt32(offset, value, true);
	                } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_INT) {
	                    dataView.setUint32(offset, value, true);
	                } else if (componentType === WEBGL_CONSTANTS.SHORT) {
	                    dataView.setInt16(offset, value, true);
	                } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
	                    dataView.setUint16(offset, value, true);
	                } else if (componentType === WEBGL_CONSTANTS.BYTE) {
	                    dataView.setInt8(offset, value);
	                } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
	                    dataView.setUint8(offset, value);
	                }
	                offset += componentSize;
	            }
	            if (offset % byteStride !== 0) {
	                offset += byteStride - offset % byteStride;
	            }
	        }
	        const bufferViewDef = {
	            buffer: this.processBuffer(dataView.buffer),
	            byteOffset: this.byteOffset,
	            byteLength: byteLength
	        };
	        if (target !== undefined) bufferViewDef.target = target;
	        if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
	            // Only define byteStride for vertex attributes.
	            bufferViewDef.byteStride = byteStride;
	        }
	        this.byteOffset += byteLength;
	        json.bufferViews.push(bufferViewDef);
	        // @TODO Merge bufferViews where possible.
	        const output = {
	            id: json.bufferViews.length - 1,
	            byteLength: 0
	        };
	        return output;
	    }
	    /**
		 * Process and generate a BufferView from an image Blob.
		 * @param {Blob} blob
		 * @return {Promise<number>} An integer
		 */ processBufferViewImage(blob) {
	        const writer = this;
	        const json = writer.json;
	        if (!json.bufferViews) json.bufferViews = [];
	        return new Promise(function(resolve) {
	            const reader = new FileReader();
	            reader.readAsArrayBuffer(blob);
	            reader.onloadend = function() {
	                const buffer = getPaddedArrayBuffer(reader.result);
	                const bufferViewDef = {
	                    buffer: writer.processBuffer(buffer),
	                    byteOffset: writer.byteOffset,
	                    byteLength: buffer.byteLength
	                };
	                writer.byteOffset += buffer.byteLength;
	                resolve(json.bufferViews.push(bufferViewDef) - 1);
	            };
	        });
	    }
	    /**
		 * Process attribute to generate an accessor
		 * @param {BufferAttribute} attribute Attribute to process
		 * @param {?BufferGeometry} geometry Geometry used for truncated draw range
		 * @param {number} [start=0]
		 * @param {number} [count=Infinity]
		 * @return {?number} Index of the processed accessor on the "accessors" array
		 */ processAccessor(attribute, geometry, start, count) {
	        const json = this.json;
	        const types = {
	            1: 'SCALAR',
	            2: 'VEC2',
	            3: 'VEC3',
	            4: 'VEC4',
	            9: 'MAT3',
	            16: 'MAT4'
	        };
	        let componentType;
	        // Detect the component type of the attribute array
	        if (attribute.array.constructor === Float32Array) {
	            componentType = WEBGL_CONSTANTS.FLOAT;
	        } else if (attribute.array.constructor === Int32Array) {
	            componentType = WEBGL_CONSTANTS.INT;
	        } else if (attribute.array.constructor === Uint32Array) {
	            componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
	        } else if (attribute.array.constructor === Int16Array) {
	            componentType = WEBGL_CONSTANTS.SHORT;
	        } else if (attribute.array.constructor === Uint16Array) {
	            componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
	        } else if (attribute.array.constructor === Int8Array) {
	            componentType = WEBGL_CONSTANTS.BYTE;
	        } else if (attribute.array.constructor === Uint8Array) {
	            componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
	        } else {
	            throw new Error('THREE.GLTFExporter: Unsupported bufferAttribute component type: ' + attribute.array.constructor.name);
	        }
	        if (start === undefined) start = 0;
	        if (count === undefined || count === Infinity) count = attribute.count;
	        // Skip creating an accessor if the attribute doesn't have data to export
	        if (count === 0) return null;
	        const minMax = getMinMax(attribute, start, count);
	        let bufferViewTarget;
	        // If geometry isn't provided, don't infer the target usage of the bufferView. For
	        // animation samplers, target must not be set.
	        if (geometry !== undefined) {
	            bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
	        }
	        const bufferView = this.processBufferView(attribute, componentType, start, count, bufferViewTarget);
	        const accessorDef = {
	            bufferView: bufferView.id,
	            byteOffset: bufferView.byteOffset,
	            componentType: componentType,
	            count: count,
	            max: minMax.max,
	            min: minMax.min,
	            type: types[attribute.itemSize]
	        };
	        if (attribute.normalized === true) accessorDef.normalized = true;
	        if (!json.accessors) json.accessors = [];
	        return json.accessors.push(accessorDef) - 1;
	    }
	    /**
		 * Process image
		 * @param  {Image} image to process
		 * @param  {number} format Identifier of the format (RGBAFormat)
		 * @param  {boolean} flipY before writing out the image
		 * @param  {string} mimeType export format
		 * @return {number}     Index of the processed texture in the "images" array
		 */ processImage(image, format, flipY, mimeType = 'image/png') {
	        if (image !== null) {
	            const writer = this;
	            const cache = writer.cache;
	            const json = writer.json;
	            const options = writer.options;
	            const pending = writer.pending;
	            if (!cache.images.has(image)) cache.images.set(image, {});
	            const cachedImages = cache.images.get(image);
	            const key = mimeType + ':flipY/' + flipY.toString();
	            if (cachedImages[key] !== undefined) return cachedImages[key];
	            if (!json.images) json.images = [];
	            const imageDef = {
	                mimeType: mimeType
	            };
	            const canvas = getCanvas();
	            canvas.width = Math.min(image.width, options.maxTextureSize);
	            canvas.height = Math.min(image.height, options.maxTextureSize);
	            const ctx = canvas.getContext('2d', {
	                willReadFrequently: true
	            });
	            if (flipY === true) {
	                ctx.translate(0, canvas.height);
	                ctx.scale(1, -1);
	            }
	            if (image.data !== undefined) {
	                if (format !== RGBAFormat) {
	                    console.error('GLTFExporter: Only RGBAFormat is supported.', format);
	                }
	                if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
	                    console.warn('GLTFExporter: Image size is bigger than maxTextureSize', image);
	                }
	                const data = new Uint8ClampedArray(image.height * image.width * 4);
	                for(let i = 0; i < data.length; i += 4){
	                    data[i + 0] = image.data[i + 0];
	                    data[i + 1] = image.data[i + 1];
	                    data[i + 2] = image.data[i + 2];
	                    data[i + 3] = image.data[i + 3];
	                }
	                ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
	            } else {
	                if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap || typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas) {
	                    ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
	                } else {
	                    throw new Error('THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.');
	                }
	            }
	            if (options.binary === true) {
	                pending.push(getToBlobPromise(canvas, mimeType).then((blob)=>writer.processBufferViewImage(blob)).then((bufferViewIndex)=>{
	                    imageDef.bufferView = bufferViewIndex;
	                }));
	            } else {
	                if (canvas.toDataURL !== undefined) {
	                    imageDef.uri = canvas.toDataURL(mimeType);
	                } else {
	                    pending.push(getToBlobPromise(canvas, mimeType).then((blob)=>new FileReader().readAsDataURL(blob)).then((dataURL)=>{
	                        imageDef.uri = dataURL;
	                    }));
	                }
	            }
	            const index = json.images.push(imageDef) - 1;
	            cachedImages[key] = index;
	            return index;
	        } else {
	            throw new Error('THREE.GLTFExporter: No valid image data found. Unable to process texture.');
	        }
	    }
	    /**
		 * Process sampler
		 * @param  {Texture} map Texture to process
		 * @return {number}      Index of the processed texture in the "samplers" array
		 */ processSampler(map) {
	        const json = this.json;
	        if (!json.samplers) json.samplers = [];
	        const samplerDef = {
	            magFilter: THREE_TO_WEBGL[map.magFilter],
	            minFilter: THREE_TO_WEBGL[map.minFilter],
	            wrapS: THREE_TO_WEBGL[map.wrapS],
	            wrapT: THREE_TO_WEBGL[map.wrapT]
	        };
	        return json.samplers.push(samplerDef) - 1;
	    }
	    /**
		 * Process texture
		 * @param  {Texture} map Map to process
		 * @return {Promise<number>} Index of the processed texture in the "textures" array
		 */ async processTextureAsync(map) {
	        const writer = this;
	        const options = writer.options;
	        const cache = this.cache;
	        const json = this.json;
	        if (cache.textures.has(map)) return cache.textures.get(map);
	        if (!json.textures) json.textures = [];
	        // make non-readable textures (e.g. CompressedTexture) readable by blitting them into a new texture
	        if (map instanceof CompressedTexture) {
	            map = await this.decompressTextureAsync(map, options.maxTextureSize);
	        }
	        let mimeType = map.userData.mimeType;
	        if (mimeType === 'image/webp') mimeType = 'image/png';
	        const textureDef = {
	            sampler: this.processSampler(map),
	            source: this.processImage(map.image, map.format, map.flipY, mimeType)
	        };
	        if (map.name) textureDef.name = map.name;
	        await this._invokeAllAsync(async function(ext) {
	            ext.writeTexture && await ext.writeTexture(map, textureDef);
	        });
	        const index = json.textures.push(textureDef) - 1;
	        cache.textures.set(map, index);
	        return index;
	    }
	    /**
		 * Process material
		 * @param  {THREE.Material} material Material to process
		 * @return {Promise<number|null>} Index of the processed material in the "materials" array
		 */ async processMaterialAsync(material) {
	        const cache = this.cache;
	        const json = this.json;
	        if (cache.materials.has(material)) return cache.materials.get(material);
	        if (material.isShaderMaterial) {
	            console.warn('GLTFExporter: THREE.ShaderMaterial not supported.');
	            return null;
	        }
	        if (!json.materials) json.materials = [];
	        // @QUESTION Should we avoid including any attribute that has the default value?
	        const materialDef = {
	            pbrMetallicRoughness: {}
	        };
	        if (material.isMeshStandardMaterial !== true && material.isMeshBasicMaterial !== true) {
	            console.warn('GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.');
	        }
	        // pbrMetallicRoughness.baseColorFactor
	        const color = material.color.toArray().concat([
	            material.opacity
	        ]);
	        if (!equalArray(color, [
	            1,
	            1,
	            1,
	            1
	        ])) {
	            materialDef.pbrMetallicRoughness.baseColorFactor = color;
	        }
	        if (material.isMeshStandardMaterial) {
	            materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
	            materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
	        } else {
	            materialDef.pbrMetallicRoughness.metallicFactor = 0;
	            materialDef.pbrMetallicRoughness.roughnessFactor = 1;
	        }
	        // pbrMetallicRoughness.metallicRoughnessTexture
	        if (material.metalnessMap || material.roughnessMap) {
	            const metalRoughTexture = await this.buildMetalRoughTextureAsync(material.metalnessMap, material.roughnessMap);
	            const metalRoughMapDef = {
	                index: await this.processTextureAsync(metalRoughTexture),
	                texCoord: metalRoughTexture.channel
	            };
	            this.applyTextureTransform(metalRoughMapDef, metalRoughTexture);
	            materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
	        }
	        // pbrMetallicRoughness.baseColorTexture
	        if (material.map) {
	            const baseColorMapDef = {
	                index: await this.processTextureAsync(material.map),
	                texCoord: material.map.channel
	            };
	            this.applyTextureTransform(baseColorMapDef, material.map);
	            materialDef.pbrMetallicRoughness.baseColorTexture = baseColorMapDef;
	        }
	        if (material.emissive) {
	            const emissive = material.emissive;
	            const maxEmissiveComponent = Math.max(emissive.r, emissive.g, emissive.b);
	            if (maxEmissiveComponent > 0) {
	                materialDef.emissiveFactor = material.emissive.toArray();
	            }
	            // emissiveTexture
	            if (material.emissiveMap) {
	                const emissiveMapDef = {
	                    index: await this.processTextureAsync(material.emissiveMap),
	                    texCoord: material.emissiveMap.channel
	                };
	                this.applyTextureTransform(emissiveMapDef, material.emissiveMap);
	                materialDef.emissiveTexture = emissiveMapDef;
	            }
	        }
	        // normalTexture
	        if (material.normalMap) {
	            const normalMapDef = {
	                index: await this.processTextureAsync(material.normalMap),
	                texCoord: material.normalMap.channel
	            };
	            if (material.normalScale && material.normalScale.x !== 1) {
	                // glTF normal scale is univariate. Ignore `y`, which may be flipped.
	                // Context: https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
	                normalMapDef.scale = material.normalScale.x;
	            }
	            this.applyTextureTransform(normalMapDef, material.normalMap);
	            materialDef.normalTexture = normalMapDef;
	        }
	        // occlusionTexture
	        if (material.aoMap) {
	            const occlusionMapDef = {
	                index: await this.processTextureAsync(material.aoMap),
	                texCoord: material.aoMap.channel
	            };
	            if (material.aoMapIntensity !== 1.0) {
	                occlusionMapDef.strength = material.aoMapIntensity;
	            }
	            this.applyTextureTransform(occlusionMapDef, material.aoMap);
	            materialDef.occlusionTexture = occlusionMapDef;
	        }
	        // alphaMode
	        if (material.transparent) {
	            materialDef.alphaMode = 'BLEND';
	        } else {
	            if (material.alphaTest > 0.0) {
	                materialDef.alphaMode = 'MASK';
	                materialDef.alphaCutoff = material.alphaTest;
	            }
	        }
	        // doubleSided
	        if (material.side === DoubleSide) materialDef.doubleSided = true;
	        if (material.name !== '') materialDef.name = material.name;
	        this.serializeUserData(material, materialDef);
	        await this._invokeAllAsync(async function(ext) {
	            ext.writeMaterialAsync && await ext.writeMaterialAsync(material, materialDef);
	        });
	        const index = json.materials.push(materialDef) - 1;
	        cache.materials.set(material, index);
	        return index;
	    }
	    /**
		 * Process mesh
		 * @param  {THREE.Mesh} mesh Mesh to process
		 * @return {Promise<number|null>} Index of the processed mesh in the "meshes" array
		 */ async processMeshAsync(mesh) {
	        const cache = this.cache;
	        const json = this.json;
	        const meshCacheKeyParts = [
	            mesh.geometry.uuid
	        ];
	        if (Array.isArray(mesh.material)) {
	            for(let i = 0, l = mesh.material.length; i < l; i++){
	                meshCacheKeyParts.push(mesh.material[i].uuid);
	            }
	        } else {
	            meshCacheKeyParts.push(mesh.material.uuid);
	        }
	        const meshCacheKey = meshCacheKeyParts.join(':');
	        if (cache.meshes.has(meshCacheKey)) return cache.meshes.get(meshCacheKey);
	        const geometry = mesh.geometry;
	        let mode;
	        // Use the correct mode
	        if (mesh.isLineSegments) {
	            mode = WEBGL_CONSTANTS.LINES;
	        } else if (mesh.isLineLoop) {
	            mode = WEBGL_CONSTANTS.LINE_LOOP;
	        } else if (mesh.isLine) {
	            mode = WEBGL_CONSTANTS.LINE_STRIP;
	        } else if (mesh.isPoints) {
	            mode = WEBGL_CONSTANTS.POINTS;
	        } else {
	            mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
	        }
	        const meshDef = {};
	        const attributes = {};
	        const primitives = [];
	        const targets = [];
	        // Conversion between attributes names in threejs and gltf spec
	        const nameConversion = {
	            uv: 'TEXCOORD_0',
	            uv1: 'TEXCOORD_1',
	            uv2: 'TEXCOORD_2',
	            uv3: 'TEXCOORD_3',
	            color: 'COLOR_0',
	            skinWeight: 'WEIGHTS_0',
	            skinIndex: 'JOINTS_0'
	        };
	        const originalNormal = geometry.getAttribute('normal');
	        if (originalNormal !== undefined && !this.isNormalizedNormalAttribute(originalNormal)) {
	            console.warn('THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.');
	            geometry.setAttribute('normal', this.createNormalizedNormalAttribute(originalNormal));
	        }
	        // @QUESTION Detect if .vertexColors = true?
	        // For every attribute create an accessor
	        let modifiedAttribute = null;
	        for(let attributeName in geometry.attributes){
	            // Ignore morph target attributes, which are exported later.
	            if (attributeName.slice(0, 5) === 'morph') continue;
	            const attribute = geometry.attributes[attributeName];
	            attributeName = nameConversion[attributeName] || attributeName.toUpperCase();
	            // Prefix all geometry attributes except the ones specifically
	            // listed in the spec; non-spec attributes are considered custom.
	            const validVertexAttributes = /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/;
	            if (!validVertexAttributes.test(attributeName)) attributeName = '_' + attributeName;
	            if (cache.attributes.has(this.getUID(attribute))) {
	                attributes[attributeName] = cache.attributes.get(this.getUID(attribute));
	                continue;
	            }
	            // Enforce glTF vertex attribute requirements:
	            // - JOINTS_0 must be UNSIGNED_BYTE or UNSIGNED_SHORT
	            // - Only custom attributes may be INT or UNSIGNED_INT
	            modifiedAttribute = null;
	            const array = attribute.array;
	            if (attributeName === 'JOINTS_0' && !(array instanceof Uint16Array) && !(array instanceof Uint8Array)) {
	                console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.');
	                modifiedAttribute = new BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
	            } else if ((array instanceof Uint32Array || array instanceof Int32Array) && !attributeName.startsWith('_')) {
	                console.warn(`GLTFExporter: Attribute "${attributeName}" converted to type FLOAT.`);
	                modifiedAttribute = GLTFExporter.Utils.toFloat32BufferAttribute(attribute);
	            }
	            const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
	            if (accessor !== null) {
	                if (!attributeName.startsWith('_')) {
	                    this.detectMeshQuantization(attributeName, attribute);
	                }
	                attributes[attributeName] = accessor;
	                cache.attributes.set(this.getUID(attribute), accessor);
	            }
	        }
	        if (originalNormal !== undefined) geometry.setAttribute('normal', originalNormal);
	        // Skip if no exportable attributes found
	        if (Object.keys(attributes).length === 0) return null;
	        // Morph targets
	        if (mesh.morphTargetInfluences !== undefined && mesh.morphTargetInfluences.length > 0) {
	            const weights = [];
	            const targetNames = [];
	            const reverseDictionary = {};
	            if (mesh.morphTargetDictionary !== undefined) {
	                for(const key in mesh.morphTargetDictionary){
	                    reverseDictionary[mesh.morphTargetDictionary[key]] = key;
	                }
	            }
	            for(let i = 0; i < mesh.morphTargetInfluences.length; ++i){
	                const target = {};
	                let warned = false;
	                for(const attributeName in geometry.morphAttributes){
	                    // glTF 2.0 morph supports only POSITION/NORMAL/TANGENT.
	                    // Three.js doesn't support TANGENT yet.
	                    if (attributeName !== 'position' && attributeName !== 'normal') {
	                        if (!warned) {
	                            console.warn('GLTFExporter: Only POSITION and NORMAL morph are supported.');
	                            warned = true;
	                        }
	                        continue;
	                    }
	                    const attribute = geometry.morphAttributes[attributeName][i];
	                    const gltfAttributeName = attributeName.toUpperCase();
	                    // Three.js morph attribute has absolute values while the one of glTF has relative values.
	                    //
	                    // glTF 2.0 Specification:
	                    // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#morph-targets
	                    const baseAttribute = geometry.attributes[attributeName];
	                    if (cache.attributes.has(this.getUID(attribute, true))) {
	                        target[gltfAttributeName] = cache.attributes.get(this.getUID(attribute, true));
	                        continue;
	                    }
	                    // Clones attribute not to override
	                    const relativeAttribute = attribute.clone();
	                    if (!geometry.morphTargetsRelative) {
	                        for(let j = 0, jl = attribute.count; j < jl; j++){
	                            for(let a = 0; a < attribute.itemSize; a++){
	                                if (a === 0) relativeAttribute.setX(j, attribute.getX(j) - baseAttribute.getX(j));
	                                if (a === 1) relativeAttribute.setY(j, attribute.getY(j) - baseAttribute.getY(j));
	                                if (a === 2) relativeAttribute.setZ(j, attribute.getZ(j) - baseAttribute.getZ(j));
	                                if (a === 3) relativeAttribute.setW(j, attribute.getW(j) - baseAttribute.getW(j));
	                            }
	                        }
	                    }
	                    target[gltfAttributeName] = this.processAccessor(relativeAttribute, geometry);
	                    cache.attributes.set(this.getUID(baseAttribute, true), target[gltfAttributeName]);
	                }
	                targets.push(target);
	                weights.push(mesh.morphTargetInfluences[i]);
	                if (mesh.morphTargetDictionary !== undefined) targetNames.push(reverseDictionary[i]);
	            }
	            meshDef.weights = weights;
	            if (targetNames.length > 0) {
	                meshDef.extras = {};
	                meshDef.extras.targetNames = targetNames;
	            }
	        }
	        const isMultiMaterial = Array.isArray(mesh.material);
	        if (isMultiMaterial && geometry.groups.length === 0) return null;
	        let didForceIndices = false;
	        if (isMultiMaterial && geometry.index === null) {
	            const indices = [];
	            for(let i = 0, il = geometry.attributes.position.count; i < il; i++){
	                indices[i] = i;
	            }
	            geometry.setIndex(indices);
	            didForceIndices = true;
	        }
	        const materials = isMultiMaterial ? mesh.material : [
	            mesh.material
	        ];
	        const groups = isMultiMaterial ? geometry.groups : [
	            {
	                materialIndex: 0,
	                start: undefined,
	                count: undefined
	            }
	        ];
	        for(let i = 0, il = groups.length; i < il; i++){
	            const primitive = {
	                mode: mode,
	                attributes: attributes
	            };
	            this.serializeUserData(geometry, primitive);
	            if (targets.length > 0) primitive.targets = targets;
	            if (geometry.index !== null) {
	                let cacheKey = this.getUID(geometry.index);
	                if (groups[i].start !== undefined || groups[i].count !== undefined) {
	                    cacheKey += ':' + groups[i].start + ':' + groups[i].count;
	                }
	                if (cache.attributes.has(cacheKey)) {
	                    primitive.indices = cache.attributes.get(cacheKey);
	                } else {
	                    primitive.indices = this.processAccessor(geometry.index, geometry, groups[i].start, groups[i].count);
	                    cache.attributes.set(cacheKey, primitive.indices);
	                }
	                if (primitive.indices === null) delete primitive.indices;
	            }
	            const material = await this.processMaterialAsync(materials[groups[i].materialIndex]);
	            if (material !== null) primitive.material = material;
	            primitives.push(primitive);
	        }
	        if (didForceIndices === true) {
	            geometry.setIndex(null);
	        }
	        meshDef.primitives = primitives;
	        if (!json.meshes) json.meshes = [];
	        await this._invokeAllAsync(function(ext) {
	            ext.writeMesh && ext.writeMesh(mesh, meshDef);
	        });
	        const index = json.meshes.push(meshDef) - 1;
	        cache.meshes.set(meshCacheKey, index);
	        return index;
	    }
	    /**
		 * If a vertex attribute with a
		 * [non-standard data type](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview)
		 * is used, it is checked whether it is a valid data type according to the
		 * [KHR_mesh_quantization](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)
		 * extension.
		 * In this case the extension is automatically added to the list of used extensions.
		 *
		 * @param {string} attributeName
		 * @param {THREE.BufferAttribute} attribute
		 */ detectMeshQuantization(attributeName, attribute) {
	        if (this.extensionsUsed[KHR_MESH_QUANTIZATION]) return;
	        let attrType = undefined;
	        switch(attribute.array.constructor){
	            case Int8Array:
	                attrType = 'byte';
	                break;
	            case Uint8Array:
	                attrType = 'unsigned byte';
	                break;
	            case Int16Array:
	                attrType = 'short';
	                break;
	            case Uint16Array:
	                attrType = 'unsigned short';
	                break;
	            default:
	                return;
	        }
	        if (attribute.normalized) attrType += ' normalized';
	        const attrNamePrefix = attributeName.split('_', 1)[0];
	        if (KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix] && KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix].includes(attrType)) {
	            this.extensionsUsed[KHR_MESH_QUANTIZATION] = true;
	            this.extensionsRequired[KHR_MESH_QUANTIZATION] = true;
	        }
	    }
	    /**
		 * Process camera
		 * @param  {THREE.Camera} camera Camera to process
		 * @return {number} Index of the processed mesh in the "camera" array
		 */ processCamera(camera) {
	        const json = this.json;
	        if (!json.cameras) json.cameras = [];
	        const isOrtho = camera.isOrthographicCamera;
	        const cameraDef = {
	            type: isOrtho ? 'orthographic' : 'perspective'
	        };
	        if (isOrtho) {
	            cameraDef.orthographic = {
	                xmag: camera.right * 2,
	                ymag: camera.top * 2,
	                zfar: camera.far <= 0 ? 0.001 : camera.far,
	                znear: camera.near < 0 ? 0 : camera.near
	            };
	        } else {
	            cameraDef.perspective = {
	                aspectRatio: camera.aspect,
	                yfov: MathUtils.degToRad(camera.fov),
	                zfar: camera.far <= 0 ? 0.001 : camera.far,
	                znear: camera.near < 0 ? 0 : camera.near
	            };
	        }
	        // Question: Is saving "type" as name intentional?
	        if (camera.name !== '') cameraDef.name = camera.type;
	        return json.cameras.push(cameraDef) - 1;
	    }
	    /**
		 * Creates glTF animation entry from AnimationClip object.
		 *
		 * Status:
		 * - Only properties listed in PATH_PROPERTIES may be animated.
		 *
		 * @param {THREE.AnimationClip} clip
		 * @param {THREE.Object3D} root
		 * @return {number|null}
		 */ processAnimation(clip, root) {
	        const json = this.json;
	        const nodeMap = this.nodeMap;
	        if (!json.animations) json.animations = [];
	        clip = GLTFExporter.Utils.mergeMorphTargetTracks(clip.clone(), root);
	        const tracks = clip.tracks;
	        const channels = [];
	        const samplers = [];
	        for(let i = 0; i < tracks.length; ++i){
	            const track = tracks[i];
	            const trackBinding = PropertyBinding.parseTrackName(track.name);
	            let trackNode = PropertyBinding.findNode(root, trackBinding.nodeName);
	            const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
	            if (trackBinding.objectName === 'bones') {
	                if (trackNode.isSkinnedMesh === true) {
	                    trackNode = trackNode.skeleton.getBoneByName(trackBinding.objectIndex);
	                } else {
	                    trackNode = undefined;
	                }
	            }
	            if (!trackNode || !trackProperty) {
	                console.warn('THREE.GLTFExporter: Could not export animation track "%s".', track.name);
	                continue;
	            }
	            const inputItemSize = 1;
	            let outputItemSize = track.values.length / track.times.length;
	            if (trackProperty === PATH_PROPERTIES.morphTargetInfluences) {
	                outputItemSize /= trackNode.morphTargetInfluences.length;
	            }
	            let interpolation;
	            // @TODO export CubicInterpolant(InterpolateSmooth) as CUBICSPLINE
	            // Detecting glTF cubic spline interpolant by checking factory method's special property
	            // GLTFCubicSplineInterpolant is a custom interpolant and track doesn't return
	            // valid value from .getInterpolation().
	            if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
	                interpolation = 'CUBICSPLINE';
	                // itemSize of CUBICSPLINE keyframe is 9
	                // (VEC3 * 3: inTangent, splineVertex, and outTangent)
	                // but needs to be stored as VEC3 so dividing by 3 here.
	                outputItemSize /= 3;
	            } else if (track.getInterpolation() === InterpolateDiscrete) {
	                interpolation = 'STEP';
	            } else {
	                interpolation = 'LINEAR';
	            }
	            samplers.push({
	                input: this.processAccessor(new BufferAttribute(track.times, inputItemSize)),
	                output: this.processAccessor(new BufferAttribute(track.values, outputItemSize)),
	                interpolation: interpolation
	            });
	            channels.push({
	                sampler: samplers.length - 1,
	                target: {
	                    node: nodeMap.get(trackNode),
	                    path: trackProperty
	                }
	            });
	        }
	        json.animations.push({
	            name: clip.name || 'clip_' + json.animations.length,
	            samplers: samplers,
	            channels: channels
	        });
	        return json.animations.length - 1;
	    }
	    /**
		 * @param {THREE.Object3D} object
		 * @return {number|null}
		 */ processSkin(object) {
	        const json = this.json;
	        const nodeMap = this.nodeMap;
	        const node = json.nodes[nodeMap.get(object)];
	        const skeleton = object.skeleton;
	        if (skeleton === undefined) return null;
	        const rootJoint = object.skeleton.bones[0];
	        if (rootJoint === undefined) return null;
	        const joints = [];
	        const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
	        const temporaryBoneInverse = new Matrix4();
	        for(let i = 0; i < skeleton.bones.length; ++i){
	            joints.push(nodeMap.get(skeleton.bones[i]));
	            temporaryBoneInverse.copy(skeleton.boneInverses[i]);
	            temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i * 16);
	        }
	        if (json.skins === undefined) json.skins = [];
	        json.skins.push({
	            inverseBindMatrices: this.processAccessor(new BufferAttribute(inverseBindMatrices, 16)),
	            joints: joints,
	            skeleton: nodeMap.get(rootJoint)
	        });
	        const skinIndex = node.skin = json.skins.length - 1;
	        return skinIndex;
	    }
	    /**
		 * Process Object3D node
		 * @param  {THREE.Object3D} object Object3D to processNodeAsync
		 * @return {Promise<number>} Index of the node in the nodes list
		 */ async processNodeAsync(object) {
	        const json = this.json;
	        const options = this.options;
	        const nodeMap = this.nodeMap;
	        if (!json.nodes) json.nodes = [];
	        const nodeDef = {};
	        if (options.trs) {
	            const rotation = object.quaternion.toArray();
	            const position = object.position.toArray();
	            const scale = object.scale.toArray();
	            if (!equalArray(rotation, [
	                0,
	                0,
	                0,
	                1
	            ])) {
	                nodeDef.rotation = rotation;
	            }
	            if (!equalArray(position, [
	                0,
	                0,
	                0
	            ])) {
	                nodeDef.translation = position;
	            }
	            if (!equalArray(scale, [
	                1,
	                1,
	                1
	            ])) {
	                nodeDef.scale = scale;
	            }
	        } else {
	            if (object.matrixAutoUpdate) {
	                object.updateMatrix();
	            }
	            if (isIdentityMatrix(object.matrix) === false) {
	                nodeDef.matrix = object.matrix.elements;
	            }
	        }
	        // We don't export empty strings name because it represents no-name in Three.js.
	        if (object.name !== '') nodeDef.name = String(object.name);
	        this.serializeUserData(object, nodeDef);
	        if (object.isMesh || object.isLine || object.isPoints) {
	            const meshIndex = await this.processMeshAsync(object);
	            if (meshIndex !== null) nodeDef.mesh = meshIndex;
	        } else if (object.isCamera) {
	            nodeDef.camera = this.processCamera(object);
	        }
	        if (object.isSkinnedMesh) this.skins.push(object);
	        if (object.children.length > 0) {
	            const children = [];
	            for(let i = 0, l = object.children.length; i < l; i++){
	                const child = object.children[i];
	                if (child.visible || options.onlyVisible === false) {
	                    const nodeIndex = await this.processNodeAsync(child);
	                    if (nodeIndex !== null) children.push(nodeIndex);
	                }
	            }
	            if (children.length > 0) nodeDef.children = children;
	        }
	        await this._invokeAllAsync(function(ext) {
	            ext.writeNode && ext.writeNode(object, nodeDef);
	        });
	        const nodeIndex = json.nodes.push(nodeDef) - 1;
	        nodeMap.set(object, nodeIndex);
	        return nodeIndex;
	    }
	    /**
		 * Process Scene
		 * @param  {Scene} scene Scene to process
		 */ async processSceneAsync(scene) {
	        const json = this.json;
	        const options = this.options;
	        if (!json.scenes) {
	            json.scenes = [];
	            json.scene = 0;
	        }
	        const sceneDef = {};
	        if (scene.name !== '') sceneDef.name = scene.name;
	        json.scenes.push(sceneDef);
	        const nodes = [];
	        for(let i = 0, l = scene.children.length; i < l; i++){
	            const child = scene.children[i];
	            if (child.visible || options.onlyVisible === false) {
	                const nodeIndex = await this.processNodeAsync(child);
	                if (nodeIndex !== null) nodes.push(nodeIndex);
	            }
	        }
	        if (nodes.length > 0) sceneDef.nodes = nodes;
	        this.serializeUserData(scene, sceneDef);
	    }
	    /**
		 * Creates a Scene to hold a list of objects and parse it
		 * @param  {Array<THREE.Object3D>} objects List of objects to process
		 */ async processObjectsAsync(objects) {
	        const scene = new Scene();
	        scene.name = 'AuxScene';
	        for(let i = 0; i < objects.length; i++){
	            // We push directly to children instead of calling `add` to prevent
	            // modify the .parent and break its original scene and hierarchy
	            scene.children.push(objects[i]);
	        }
	        await this.processSceneAsync(scene);
	    }
	    /**
		 * @param {THREE.Object3D|Array<THREE.Object3D>} input
		 */ async processInputAsync(input) {
	        const options = this.options;
	        input = input instanceof Array ? input : [
	            input
	        ];
	        await this._invokeAllAsync(function(ext) {
	            ext.beforeParse && ext.beforeParse(input);
	        });
	        const objectsWithoutScene = [];
	        for(let i = 0; i < input.length; i++){
	            if (input[i] instanceof Scene) {
	                await this.processSceneAsync(input[i]);
	            } else {
	                objectsWithoutScene.push(input[i]);
	            }
	        }
	        if (objectsWithoutScene.length > 0) {
	            await this.processObjectsAsync(objectsWithoutScene);
	        }
	        for(let i = 0; i < this.skins.length; ++i){
	            this.processSkin(this.skins[i]);
	        }
	        for(let i = 0; i < options.animations.length; ++i){
	            this.processAnimation(options.animations[i], input[0]);
	        }
	        await this._invokeAllAsync(function(ext) {
	            ext.afterParse && ext.afterParse(input);
	        });
	    }
	    async _invokeAllAsync(func) {
	        for(let i = 0, il = this.plugins.length; i < il; i++){
	            await func(this.plugins[i]);
	        }
	    }
	    constructor(){
	        this.plugins = [];
	        this.options = {};
	        this.pending = [];
	        this.buffers = [];
	        this.byteOffset = 0;
	        this.buffers = [];
	        this.nodeMap = new Map();
	        this.skins = [];
	        this.extensionsUsed = {};
	        this.extensionsRequired = {};
	        this.uids = new Map();
	        this.uid = 0;
	        this.json = {
	            asset: {
	                version: '2.0',
	                generator: 'THREE.GLTFExporter r' + REVISION
	            }
	        };
	        this.cache = {
	            meshes: new Map(),
	            attributes: new Map(),
	            attributesNormalized: new Map(),
	            materials: new Map(),
	            textures: new Map(),
	            images: new Map()
	        };
	        this.textureUtils = null;
	    }
	}
	/**
	 * Punctual Lights Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
	 */ class GLTFLightExtension {
	    writeNode(light, nodeDef) {
	        if (!light.isLight) return;
	        if (!light.isDirectionalLight && !light.isPointLight && !light.isSpotLight) {
	            console.warn('THREE.GLTFExporter: Only directional, point, and spot lights are supported.', light);
	            return;
	        }
	        const writer = this.writer;
	        const json = writer.json;
	        const extensionsUsed = writer.extensionsUsed;
	        const lightDef = {};
	        if (light.name) lightDef.name = light.name;
	        lightDef.color = light.color.toArray();
	        lightDef.intensity = light.intensity;
	        if (light.isDirectionalLight) {
	            lightDef.type = 'directional';
	        } else if (light.isPointLight) {
	            lightDef.type = 'point';
	            if (light.distance > 0) lightDef.range = light.distance;
	        } else if (light.isSpotLight) {
	            lightDef.type = 'spot';
	            if (light.distance > 0) lightDef.range = light.distance;
	            lightDef.spot = {};
	            lightDef.spot.innerConeAngle = (1.0 - light.penumbra) * light.angle;
	            lightDef.spot.outerConeAngle = light.angle;
	        }
	        if (light.decay !== undefined && light.decay !== 2) {
	            console.warn('THREE.GLTFExporter: Light decay may be lost. glTF is physically-based, ' + 'and expects light.decay=2.');
	        }
	        if (light.target && (light.target.parent !== light || light.target.position.x !== 0 || light.target.position.y !== 0 || light.target.position.z !== -1)) {
	            console.warn('THREE.GLTFExporter: Light direction may be lost. For best results, ' + 'make light.target a child of the light with position 0,0,-1.');
	        }
	        if (!extensionsUsed[this.name]) {
	            json.extensions = json.extensions || {};
	            json.extensions[this.name] = {
	                lights: []
	            };
	            extensionsUsed[this.name] = true;
	        }
	        const lights = json.extensions[this.name].lights;
	        lights.push(lightDef);
	        nodeDef.extensions = nodeDef.extensions || {};
	        nodeDef.extensions[this.name] = {
	            light: lights.length - 1
	        };
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_lights_punctual';
	    }
	}
	/**
	 * Unlit Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
	 */ class GLTFMaterialsUnlitExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshBasicMaterial) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = {};
	        extensionsUsed[this.name] = true;
	        materialDef.pbrMetallicRoughness.metallicFactor = 0.0;
	        materialDef.pbrMetallicRoughness.roughnessFactor = 0.9;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_unlit';
	    }
	}
	/**
	 * Clearcoat Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
	 */ class GLTFMaterialsClearcoatExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.clearcoat === 0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.clearcoatFactor = material.clearcoat;
	        if (material.clearcoatMap) {
	            const clearcoatMapDef = {
	                index: await writer.processTextureAsync(material.clearcoatMap),
	                texCoord: material.clearcoatMap.channel
	            };
	            writer.applyTextureTransform(clearcoatMapDef, material.clearcoatMap);
	            extensionDef.clearcoatTexture = clearcoatMapDef;
	        }
	        extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
	        if (material.clearcoatRoughnessMap) {
	            const clearcoatRoughnessMapDef = {
	                index: await writer.processTextureAsync(material.clearcoatRoughnessMap),
	                texCoord: material.clearcoatRoughnessMap.channel
	            };
	            writer.applyTextureTransform(clearcoatRoughnessMapDef, material.clearcoatRoughnessMap);
	            extensionDef.clearcoatRoughnessTexture = clearcoatRoughnessMapDef;
	        }
	        if (material.clearcoatNormalMap) {
	            const clearcoatNormalMapDef = {
	                index: await writer.processTextureAsync(material.clearcoatNormalMap),
	                texCoord: material.clearcoatNormalMap.channel
	            };
	            if (material.clearcoatNormalScale.x !== 1) clearcoatNormalMapDef.scale = material.clearcoatNormalScale.x;
	            writer.applyTextureTransform(clearcoatNormalMapDef, material.clearcoatNormalMap);
	            extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
	        }
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_clearcoat';
	    }
	}
	/**
	 * Materials dispersion Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_dispersion
	 */ class GLTFMaterialsDispersionExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.dispersion === 0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.dispersion = material.dispersion;
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_dispersion';
	    }
	}
	/**
	 * Iridescence Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence
	 */ class GLTFMaterialsIridescenceExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.iridescence === 0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.iridescenceFactor = material.iridescence;
	        if (material.iridescenceMap) {
	            const iridescenceMapDef = {
	                index: await writer.processTextureAsync(material.iridescenceMap),
	                texCoord: material.iridescenceMap.channel
	            };
	            writer.applyTextureTransform(iridescenceMapDef, material.iridescenceMap);
	            extensionDef.iridescenceTexture = iridescenceMapDef;
	        }
	        extensionDef.iridescenceIor = material.iridescenceIOR;
	        extensionDef.iridescenceThicknessMinimum = material.iridescenceThicknessRange[0];
	        extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[1];
	        if (material.iridescenceThicknessMap) {
	            const iridescenceThicknessMapDef = {
	                index: await writer.processTextureAsync(material.iridescenceThicknessMap),
	                texCoord: material.iridescenceThicknessMap.channel
	            };
	            writer.applyTextureTransform(iridescenceThicknessMapDef, material.iridescenceThicknessMap);
	            extensionDef.iridescenceThicknessTexture = iridescenceThicknessMapDef;
	        }
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_iridescence';
	    }
	}
	/**
	 * Transmission Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
	 */ class GLTFMaterialsTransmissionExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.transmissionFactor = material.transmission;
	        if (material.transmissionMap) {
	            const transmissionMapDef = {
	                index: await writer.processTextureAsync(material.transmissionMap),
	                texCoord: material.transmissionMap.channel
	            };
	            writer.applyTextureTransform(transmissionMapDef, material.transmissionMap);
	            extensionDef.transmissionTexture = transmissionMapDef;
	        }
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_transmission';
	    }
	}
	/**
	 * Materials Volume Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume
	 */ class GLTFMaterialsVolumeExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.thicknessFactor = material.thickness;
	        if (material.thicknessMap) {
	            const thicknessMapDef = {
	                index: await writer.processTextureAsync(material.thicknessMap),
	                texCoord: material.thicknessMap.channel
	            };
	            writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
	            extensionDef.thicknessTexture = thicknessMapDef;
	        }
	        if (material.attenuationDistance !== Infinity) {
	            extensionDef.attenuationDistance = material.attenuationDistance;
	        }
	        extensionDef.attenuationColor = material.attenuationColor.toArray();
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_volume';
	    }
	}
	/**
	 * Materials ior Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior
	 */ class GLTFMaterialsIorExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.ior === 1.5) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.ior = material.ior;
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_ior';
	    }
	}
	/**
	 * Materials specular Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular
	 */ class GLTFMaterialsSpecularExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.specularIntensity === 1.0 && material.specularColor.equals(DEFAULT_SPECULAR_COLOR) && !material.specularIntensityMap && !material.specularColorMap) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        if (material.specularIntensityMap) {
	            const specularIntensityMapDef = {
	                index: await writer.processTextureAsync(material.specularIntensityMap),
	                texCoord: material.specularIntensityMap.channel
	            };
	            writer.applyTextureTransform(specularIntensityMapDef, material.specularIntensityMap);
	            extensionDef.specularTexture = specularIntensityMapDef;
	        }
	        if (material.specularColorMap) {
	            const specularColorMapDef = {
	                index: await writer.processTextureAsync(material.specularColorMap),
	                texCoord: material.specularColorMap.channel
	            };
	            writer.applyTextureTransform(specularColorMapDef, material.specularColorMap);
	            extensionDef.specularColorTexture = specularColorMapDef;
	        }
	        extensionDef.specularFactor = material.specularIntensity;
	        extensionDef.specularColorFactor = material.specularColor.toArray();
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_specular';
	    }
	}
	/**
	 * Sheen Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
	 */ class GLTFMaterialsSheenExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.sheen == 0.0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        if (material.sheenRoughnessMap) {
	            const sheenRoughnessMapDef = {
	                index: await writer.processTextureAsync(material.sheenRoughnessMap),
	                texCoord: material.sheenRoughnessMap.channel
	            };
	            writer.applyTextureTransform(sheenRoughnessMapDef, material.sheenRoughnessMap);
	            extensionDef.sheenRoughnessTexture = sheenRoughnessMapDef;
	        }
	        if (material.sheenColorMap) {
	            const sheenColorMapDef = {
	                index: await writer.processTextureAsync(material.sheenColorMap),
	                texCoord: material.sheenColorMap.channel
	            };
	            writer.applyTextureTransform(sheenColorMapDef, material.sheenColorMap);
	            extensionDef.sheenColorTexture = sheenColorMapDef;
	        }
	        extensionDef.sheenRoughnessFactor = material.sheenRoughness;
	        extensionDef.sheenColorFactor = material.sheenColor.toArray();
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_sheen';
	    }
	}
	/**
	 * Anisotropy Materials Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_anisotropy
	 */ class GLTFMaterialsAnisotropyExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshPhysicalMaterial || material.anisotropy == 0.0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        if (material.anisotropyMap) {
	            const anisotropyMapDef = {
	                index: await writer.processTextureAsync(material.anisotropyMap)
	            };
	            writer.applyTextureTransform(anisotropyMapDef, material.anisotropyMap);
	            extensionDef.anisotropyTexture = anisotropyMapDef;
	        }
	        extensionDef.anisotropyStrength = material.anisotropy;
	        extensionDef.anisotropyRotation = material.anisotropyRotation;
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_anisotropy';
	    }
	}
	/**
	 * Materials Emissive Strength Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md
	 */ class GLTFMaterialsEmissiveStrengthExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshStandardMaterial || material.emissiveIntensity === 1.0) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        extensionDef.emissiveStrength = material.emissiveIntensity;
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_emissive_strength';
	    }
	}
	/**
	 * Materials bump Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump
	 */ class GLTFMaterialsBumpExtension {
	    async writeMaterialAsync(material, materialDef) {
	        if (!material.isMeshStandardMaterial || material.bumpScale === 1 && !material.bumpMap) return;
	        const writer = this.writer;
	        const extensionsUsed = writer.extensionsUsed;
	        const extensionDef = {};
	        if (material.bumpMap) {
	            const bumpMapDef = {
	                index: await writer.processTextureAsync(material.bumpMap),
	                texCoord: material.bumpMap.channel
	            };
	            writer.applyTextureTransform(bumpMapDef, material.bumpMap);
	            extensionDef.bumpTexture = bumpMapDef;
	        }
	        extensionDef.bumpFactor = material.bumpScale;
	        materialDef.extensions = materialDef.extensions || {};
	        materialDef.extensions[this.name] = extensionDef;
	        extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'EXT_materials_bump';
	    }
	}
	/**
	 * GPU Instancing Extension
	 *
	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing
	 */ class GLTFMeshGpuInstancing {
	    writeNode(object, nodeDef) {
	        if (!object.isInstancedMesh) return;
	        const writer = this.writer;
	        const mesh = object;
	        const translationAttr = new Float32Array(mesh.count * 3);
	        const rotationAttr = new Float32Array(mesh.count * 4);
	        const scaleAttr = new Float32Array(mesh.count * 3);
	        const matrix = new Matrix4();
	        const position = new Vector3();
	        const quaternion = new Quaternion();
	        const scale = new Vector3();
	        for(let i = 0; i < mesh.count; i++){
	            mesh.getMatrixAt(i, matrix);
	            matrix.decompose(position, quaternion, scale);
	            position.toArray(translationAttr, i * 3);
	            quaternion.toArray(rotationAttr, i * 4);
	            scale.toArray(scaleAttr, i * 3);
	        }
	        const attributes = {
	            TRANSLATION: writer.processAccessor(new BufferAttribute(translationAttr, 3)),
	            ROTATION: writer.processAccessor(new BufferAttribute(rotationAttr, 4)),
	            SCALE: writer.processAccessor(new BufferAttribute(scaleAttr, 3))
	        };
	        if (mesh.instanceColor) attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
	        nodeDef.extensions = nodeDef.extensions || {};
	        nodeDef.extensions[this.name] = {
	            attributes
	        };
	        writer.extensionsUsed[this.name] = true;
	        writer.extensionsRequired[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'EXT_mesh_gpu_instancing';
	    }
	}
	/**
	 * Static utility functions
	 */ GLTFExporter.Utils = {
	    insertKeyframe: function(track, time) {
	        const tolerance = 0.001; // 1ms
	        const valueSize = track.getValueSize();
	        const times = new track.TimeBufferType(track.times.length + 1);
	        const values = new track.ValueBufferType(track.values.length + valueSize);
	        const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
	        let index;
	        if (track.times.length === 0) {
	            times[0] = time;
	            for(let i = 0; i < valueSize; i++){
	                values[i] = 0;
	            }
	            index = 0;
	        } else if (time < track.times[0]) {
	            if (Math.abs(track.times[0] - time) < tolerance) return 0;
	            times[0] = time;
	            times.set(track.times, 1);
	            values.set(interpolant.evaluate(time), 0);
	            values.set(track.values, valueSize);
	            index = 0;
	        } else if (time > track.times[track.times.length - 1]) {
	            if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
	                return track.times.length - 1;
	            }
	            times[times.length - 1] = time;
	            times.set(track.times, 0);
	            values.set(track.values, 0);
	            values.set(interpolant.evaluate(time), track.values.length);
	            index = times.length - 1;
	        } else {
	            for(let i = 0; i < track.times.length; i++){
	                if (Math.abs(track.times[i] - time) < tolerance) return i;
	                if (track.times[i] < time && track.times[i + 1] > time) {
	                    times.set(track.times.slice(0, i + 1), 0);
	                    times[i + 1] = time;
	                    times.set(track.times.slice(i + 1), i + 2);
	                    values.set(track.values.slice(0, (i + 1) * valueSize), 0);
	                    values.set(interpolant.evaluate(time), (i + 1) * valueSize);
	                    values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
	                    index = i + 1;
	                    break;
	                }
	            }
	        }
	        track.times = times;
	        track.values = values;
	        return index;
	    },
	    mergeMorphTargetTracks: function(clip, root) {
	        const tracks = [];
	        const mergedTracks = {};
	        const sourceTracks = clip.tracks;
	        for(let i = 0; i < sourceTracks.length; ++i){
	            let sourceTrack = sourceTracks[i];
	            const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name);
	            const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
	            if (sourceTrackBinding.propertyName !== 'morphTargetInfluences' || sourceTrackBinding.propertyIndex === undefined) {
	                // Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
	                tracks.push(sourceTrack);
	                continue;
	            }
	            if (sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear) {
	                if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
	                    // This should never happen, because glTF morph target animations
	                    // affect all targets already.
	                    throw new Error('THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.');
	                }
	                console.warn('THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.');
	                sourceTrack = sourceTrack.clone();
	                sourceTrack.setInterpolation(InterpolateLinear);
	            }
	            const targetCount = sourceTrackNode.morphTargetInfluences.length;
	            const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
	            if (targetIndex === undefined) {
	                throw new Error('THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex);
	            }
	            let mergedTrack;
	            // If this is the first time we've seen this object, create a new
	            // track to store merged keyframe data for each morph target.
	            if (mergedTracks[sourceTrackNode.uuid] === undefined) {
	                mergedTrack = sourceTrack.clone();
	                const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
	                for(let j = 0; j < mergedTrack.times.length; j++){
	                    values[j * targetCount + targetIndex] = mergedTrack.values[j];
	                }
	                // We need to take into consideration the intended target node
	                // of our original un-merged morphTarget animation.
	                mergedTrack.name = (sourceTrackBinding.nodeName || '') + '.morphTargetInfluences';
	                mergedTrack.values = values;
	                mergedTracks[sourceTrackNode.uuid] = mergedTrack;
	                tracks.push(mergedTrack);
	                continue;
	            }
	            const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
	            mergedTrack = mergedTracks[sourceTrackNode.uuid];
	            // For every existing keyframe of the merged track, write a (possibly
	            // interpolated) value from the source track.
	            for(let j = 0; j < mergedTrack.times.length; j++){
	                mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
	            }
	            // For every existing keyframe of the source track, write a (possibly
	            // new) keyframe to the merged track. Values from the previous loop may
	            // be written again, but keyframes are de-duplicated.
	            for(let j = 0; j < sourceTrack.times.length; j++){
	                const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
	                mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
	            }
	        }
	        clip.tracks = tracks;
	        return clip;
	    },
	    toFloat32BufferAttribute: function(srcAttribute) {
	        const dstAttribute = new BufferAttribute(new Float32Array(srcAttribute.count * srcAttribute.itemSize), srcAttribute.itemSize, false);
	        if (!srcAttribute.normalized && !srcAttribute.isInterleavedBufferAttribute) {
	            dstAttribute.array.set(srcAttribute.array);
	            return dstAttribute;
	        }
	        for(let i = 0, il = srcAttribute.count; i < il; i++){
	            for(let j = 0; j < srcAttribute.itemSize; j++){
	                dstAttribute.setComponent(i, j, srcAttribute.getComponent(i, j));
	            }
	        }
	        return dstAttribute;
	    }
	};

	const compatibleObject = (object)=>{
	    return object.material !== undefined &&
	    object.userData &&
	    object.userData.variantMaterials &&
	    !!Array.from(object.userData.variantMaterials.values()).filter((m)=>compatibleMaterial(m.material));
	};
	 const compatibleMaterial = (material)=>{
	    return material && material.isMaterial && !Array.isArray(material);
	};
	class GLTFExporterMaterialsVariantsExtension {
	    beforeParse(objects) {
	        const variantNameSet = new Set();
	        const addVariantNames = (o)=>{
	            if (!compatibleObject(o)) {
	                return;
	            }
	            const variantMaterials = o.userData.variantMaterials;
	            const variantDataMap = o.userData.variantData;
	            for (const [variantName, variantData] of variantDataMap){
	                const variantMaterial = variantMaterials.get(variantData.index);
	                if (variantMaterial && compatibleMaterial(variantMaterial.material)) {
	                    variantNameSet.add(variantName);
	                }
	            }
	        };
	        if (Array.isArray(objects)) {
	            for (const object of objects){
	                object.traverse(addVariantNames);
	            }
	        } else {
	            objects.traverse(addVariantNames);
	        }
	        variantNameSet.forEach((name)=>this.variantNames.push(name));
	    }
	    async writeMesh(mesh, meshDef) {
	        if (!compatibleObject(mesh)) {
	            return;
	        }
	        const userData = mesh.userData;
	        const variantMaterials = userData.variantMaterials;
	        const variantDataMap = userData.variantData;
	        const mappingTable = new Map();
	        const reIndexedVariants = new Map();
	        const variants = Array.from(variantDataMap.values()).sort((a, b)=>{
	            return a.index - b.index;
	        });
	        for (const [i, variantData] of variants.entries()){
	            reIndexedVariants.set(variantData.index, i);
	        }
	        for (const variantData of variantDataMap.values()){
	            const variantInstance = variantMaterials.get(variantData.index);
	            if (!variantInstance || !compatibleMaterial(variantInstance.material)) {
	                continue;
	            }
	            const materialIndex = await this.writer.processMaterialAsync(variantInstance.material);
	            if (!mappingTable.has(materialIndex)) {
	                mappingTable.set(materialIndex, {
	                    material: materialIndex,
	                    variants: []
	                });
	            }
	            mappingTable.get(materialIndex).variants.push(reIndexedVariants.get(variantData.index));
	        }
	        const mappingsDef = Array.from(mappingTable.values()).map((m)=>{
	            return m.variants.sort((a, b)=>a - b) && m;
	        }).sort((a, b)=>a.material - b.material);
	        if (mappingsDef.length === 0) {
	            return;
	        }
	        const originalMaterialIndex = compatibleMaterial(userData.originalMaterial) ? await this.writer.processMaterialAsync(userData.originalMaterial) : -1;
	        for (const primitiveDef of meshDef.primitives){
	            if (originalMaterialIndex >= 0) {
	                primitiveDef.material = originalMaterialIndex;
	            }
	            primitiveDef.extensions = primitiveDef.extensions || {};
	            primitiveDef.extensions[this.name] = {
	                mappings: mappingsDef
	            };
	        }
	    }
	    afterParse() {
	        if (this.variantNames.length === 0) {
	            return;
	        }
	        const root = this.writer.json;
	        root.extensions = root.extensions || {};
	        const variantsDef = this.variantNames.map((n)=>{
	            return {
	                name: n
	            };
	        });
	        root.extensions[this.name] = {
	            variants: variantsDef
	        };
	        this.writer.extensionsUsed[this.name] = true;
	    }
	    constructor(writer){
	        this.writer = writer;
	        this.name = 'KHR_materials_variants';
	        this.variantNames = [];
	    }
	}

	class SessionLightProbe {
	    updateReflection() {
	        const textureProperties = this.renderer.properties.get(this.xrLight.environment);
	        if (textureProperties) {
	            const cubeMap = this.xrWebGLBinding.getReflectionCubeMap(this.lightProbe);
	            if (cubeMap) {
	                textureProperties.__webglTexture = cubeMap;
	                this.xrLight.environment.needsPMREMUpdate = true;
	            }
	        }
	    }
	    onXRFrame(time, xrFrame) {
	        // If either this object or the XREstimatedLight has been destroyed, stop
	        // running the frame loop.
	        if (!this.xrLight) {
	            return;
	        }
	        const session = xrFrame.session;
	        session.requestAnimationFrame(this.frameCallback);
	        const lightEstimate = xrFrame.getLightEstimate(this.lightProbe);
	        if (lightEstimate) {
	            // We can copy the estimate's spherical harmonics array directly into the light probe.
	            this.xrLight.lightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);
	            this.xrLight.lightProbe.intensity = 1.0;
	            // For the directional light we have to normalize the color and set the scalar as the
	            // intensity, since WebXR can return color values that exceed 1.0.
	            const intensityScalar = Math.max(1.0, Math.max(lightEstimate.primaryLightIntensity.x, Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)));
	            this.xrLight.directionalLight.color.setRGB(lightEstimate.primaryLightIntensity.x / intensityScalar, lightEstimate.primaryLightIntensity.y / intensityScalar, lightEstimate.primaryLightIntensity.z / intensityScalar);
	            this.xrLight.directionalLight.intensity = intensityScalar;
	            this.xrLight.directionalLight.position.copy(lightEstimate.primaryLightDirection);
	            if (this.estimationStartCallback) {
	                this.estimationStartCallback();
	                this.estimationStartCallback = null;
	            }
	        }
	    }
	    dispose() {
	        this.xrLight = null;
	        this.renderer = null;
	        this.lightProbe = null;
	        this.xrWebGLBinding = null;
	    }
	    constructor(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback){
	        this.xrLight = xrLight;
	        this.renderer = renderer;
	        this.lightProbe = lightProbe;
	        this.xrWebGLBinding = null;
	        this.estimationStartCallback = estimationStartCallback;
	        this.frameCallback = this.onXRFrame.bind(this);
	        const session = renderer.xr.getSession();
	        // If the XRWebGLBinding class is available then we can also query an
	        // estimated reflection cube map.
	        if (environmentEstimation && 'XRWebGLBinding' in window) {
	            // This is the simplest way I know of to initialize a WebGL cubemap in Three.
	            const cubeRenderTarget = new WebGLCubeRenderTarget(16);
	            xrLight.environment = cubeRenderTarget.texture;
	            const gl = renderer.getContext();
	            // Ensure that we have any extensions needed to use the preferred cube map format.
	            switch(session.preferredReflectionFormat){
	                case 'srgba8':
	                    gl.getExtension('EXT_sRGB');
	                    break;
	                case 'rgba16f':
	                    gl.getExtension('OES_texture_half_float');
	                    break;
	            }
	            this.xrWebGLBinding = new XRWebGLBinding(session, gl);
	            this.lightProbe.addEventListener('reflectionchange', ()=>{
	                this.updateReflection();
	            });
	        }
	        // Start monitoring the XR animation frame loop to look for lighting
	        // estimation changes.
	        session.requestAnimationFrame(this.frameCallback);
	    }
	}
	class XREstimatedLight extends Group {
	    constructor(renderer, environmentEstimation = true){
	        super();
	        this.lightProbe = new LightProbe();
	        this.lightProbe.intensity = 0;
	        this.add(this.lightProbe);
	        this.directionalLight = new DirectionalLight();
	        this.directionalLight.intensity = 0;
	        this.add(this.directionalLight);
	        // Will be set to a cube map in the SessionLightProbe if environment estimation is
	        // available and requested.
	        this.environment = null;
	        let sessionLightProbe = null;
	        let estimationStarted = false;
	        renderer.xr.addEventListener('sessionstart', ()=>{
	            const session = renderer.xr.getSession();
	            if ('requestLightProbe' in session) {
	                session.requestLightProbe({
	                    reflectionFormat: session.preferredReflectionFormat
	                }).then((probe)=>{
	                    sessionLightProbe = new SessionLightProbe(this, renderer, probe, environmentEstimation, ()=>{
	                        estimationStarted = true;
	                        // Fired to indicate that the estimated lighting values are now being updated.
	                        this.dispatchEvent({
	                            type: 'estimationstart'
	                        });
	                    });
	                });
	            }
	        });
	        renderer.xr.addEventListener('sessionend', ()=>{
	            if (sessionLightProbe) {
	                sessionLightProbe.dispose();
	                sessionLightProbe = null;
	            }
	            if (estimationStarted) {
	                // Fired to indicate that the estimated lighting values are no longer being updated.
	                this.dispatchEvent({
	                    type: 'estimationend'
	                });
	            }
	        });
	        // Done inline to provide access to sessionLightProbe.
	        this.dispose = ()=>{
	            if (sessionLightProbe) {
	                sessionLightProbe.dispose();
	                sessionLightProbe = null;
	            }
	            this.remove(this.lightProbe);
	            this.lightProbe = null;
	            this.remove(this.directionalLight);
	            this.directionalLight = null;
	            this.environment = null;
	        };
	    }
	}

	const SETTLING_TIME = 10000;
	const MIN_DECAY_MILLISECONDS = 0.001;
	const DECAY_MILLISECONDS = 50;
	 class Damper {
	    setDecayTime(decayMilliseconds) {
	        this.naturalFrequency = 1 / Math.max(MIN_DECAY_MILLISECONDS, decayMilliseconds);
	    }
	    update(x, xGoal, timeStepMilliseconds, xNormalization) {
	        const nilSpeed = 0.0002 * this.naturalFrequency;
	        if (x == null || xNormalization === 0) {
	            return xGoal;
	        }
	        if (x === xGoal && this.velocity === 0) {
	            return xGoal;
	        }
	        if (timeStepMilliseconds < 0) {
	            return x;
	        }
	        const deltaX = x - xGoal;
	        const intermediateVelocity = this.velocity + this.naturalFrequency * deltaX;
	        const intermediateX = deltaX + timeStepMilliseconds * intermediateVelocity;
	        const decay = Math.exp(-this.naturalFrequency * timeStepMilliseconds);
	        const newVelocity = (intermediateVelocity - this.naturalFrequency * intermediateX) * decay;
	        const acceleration = -this.naturalFrequency * (newVelocity + intermediateVelocity * decay);
	        if (Math.abs(newVelocity) < nilSpeed * Math.abs(xNormalization) && acceleration * deltaX >= 0) {
	            this.velocity = 0;
	            return xGoal;
	        } else {
	            this.velocity = newVelocity;
	            return xGoal + intermediateX * decay;
	        }
	    }
	    constructor(decayMilliseconds = DECAY_MILLISECONDS){
	        this.velocity = 0;
	        this.naturalFrequency = 0;
	        this.setDecayTime(decayMilliseconds);
	    }
	}

	const RADIUS = 0.2;
	const LINE_WIDTH = 0.03;
	const MAX_OPACITY = 0.75;
	const SEGMENTS = 12;
	const DELTA_PHI = Math.PI / (2 * SEGMENTS);
	const vector2$1 = new Vector2();
	 const addCorner = (vertices, cornerX, cornerY)=>{
	    let phi = cornerX > 0 ? cornerY > 0 ? 0 : -Math.PI / 2 : cornerY > 0 ? Math.PI / 2 : Math.PI;
	    for(let i = 0; i <= SEGMENTS; ++i){
	        vertices.push(cornerX + (RADIUS - LINE_WIDTH) * Math.cos(phi), cornerY + (RADIUS - LINE_WIDTH) * Math.sin(phi), 0, cornerX + RADIUS * Math.cos(phi), cornerY + RADIUS * Math.sin(phi), 0);
	        phi += DELTA_PHI;
	    }
	};
	 class PlacementBox extends Mesh {
	 getHit(scene, screenX, screenY) {
	        vector2$1.set(screenX, -screenY);
	        this.hitPlane.visible = true;
	        const hitResult = scene.positionAndNormalFromPoint(vector2$1, this.hitPlane);
	        this.hitPlane.visible = false;
	        return hitResult == null ? null : hitResult.position;
	    }
	    getExpandedHit(scene, screenX, screenY) {
	        this.hitPlane.scale.set(1000, 1000, 1000);
	        this.hitPlane.updateMatrixWorld();
	        const hitResult = this.getHit(scene, screenX, screenY);
	        this.hitPlane.scale.set(1, 1, 1);
	        return hitResult;
	    }
	    controllerIntersection(scene, controller) {
	        this.hitBox.visible = true;
	        const hitResult = scene.hitFromController(controller, this.hitBox);
	        this.hitBox.visible = false;
	        return hitResult;
	    }
	 set offsetHeight(offset) {
	        offset -= 0.001;
	        if (this.side === 'back') {
	            this.position.z = this.shadowHeight + offset;
	        } else {
	            this.position.y = this.shadowHeight + offset;
	        }
	    }
	    get offsetHeight() {
	        if (this.side === 'back') {
	            return this.position.z - this.shadowHeight;
	        } else {
	            return this.position.y - this.shadowHeight;
	        }
	    }
	 set show(visible) {
	        this.goalOpacity = visible ? MAX_OPACITY : 0;
	    }
	 updateOpacity(delta) {
	        const material = this.material;
	        material.opacity = this.opacityDamper.update(material.opacity, this.goalOpacity, delta, 1);
	        this.visible = material.opacity > 0;
	    }
	 dispose() {
	        const { geometry, material } = this.hitPlane;
	        geometry.dispose();
	        material.dispose();
	        this.hitBox.geometry.dispose();
	        this.hitBox.material.dispose();
	        this.geometry.dispose();
	        this.material.dispose();
	        this.hitBox.removeFromParent();
	        this.removeFromParent();
	    }
	    constructor(scene, side){
	        const geometry = new BufferGeometry();
	        const triangles = [];
	        const vertices = [];
	        const { size, boundingBox } = scene;
	        const x = size.x / 2;
	        const y = (side === 'back' ? size.y : size.z) / 2;
	        addCorner(vertices, x, y);
	        addCorner(vertices, -x, y);
	        addCorner(vertices, -x, -y);
	        addCorner(vertices, x, -y);
	        const numVertices = vertices.length / 3;
	        for(let i = 0; i < numVertices - 2; i += 2){
	            triangles.push(i, i + 1, i + 3, i, i + 3, i + 2);
	        }
	        const i = numVertices - 2;
	        triangles.push(i, i + 1, 1, i, 1, 0);
	        geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
	        geometry.setIndex(triangles);
	        super(geometry);
	        this.side = side;
	        const material = this.material;
	        material.side = DoubleSide;
	        material.transparent = true;
	        material.opacity = 0;
	        this.goalOpacity = 0;
	        this.opacityDamper = new Damper();
	        this.hitPlane = new Mesh(new PlaneGeometry(2 * (x + RADIUS), 2 * (y + RADIUS)));
	        this.hitPlane.visible = false;
	        this.hitPlane.material.side = DoubleSide;
	        this.add(this.hitPlane);
	        this.hitBox = new Mesh(new BoxGeometry(size.x + 2 * RADIUS, size.y + RADIUS, size.z + 2 * RADIUS));
	        this.hitBox.visible = false;
	        this.hitBox.material.side = DoubleSide;
	        this.add(this.hitBox);
	        boundingBox.getCenter(this.position);
	        switch(side){
	            case 'bottom':
	                this.rotateX(-Math.PI / 2);
	                this.shadowHeight = boundingBox.min.y;
	                this.position.y = this.shadowHeight;
	                break;
	            case 'back':
	                this.shadowHeight = boundingBox.min.z;
	                this.position.z = this.shadowHeight;
	        }
	        scene.target.add(this);
	        this.hitBox.position.y = (size.y + RADIUS) / 2 + boundingBox.min.y;
	        scene.target.add(this.hitBox);
	        this.offsetHeight = 0;
	    }
	}

	const numberNode = (value, unit)=>({
	        type: 'number',
	        number: value,
	        unit
	    });
	 const parseExpressions = (()=>{
	    const cache = {};
	    const MAX_PARSE_ITERATIONS = 1000;
	    return (inputString)=>{
	        const cacheKey = inputString;
	        if (cacheKey in cache) {
	            return cache[cacheKey];
	        }
	        const expressions = [];
	        let parseIterations = 0;
	        while(inputString){
	            if (++parseIterations > MAX_PARSE_ITERATIONS) {
	                inputString = '';
	                break;
	            }
	            const expressionParseResult = parseExpression(inputString);
	            const expression = expressionParseResult.nodes[0];
	            if (expression == null || expression.terms.length === 0) {
	                break;
	            }
	            expressions.push(expression);
	            inputString = expressionParseResult.remainingInput;
	        }
	        return cache[cacheKey] = expressions;
	    };
	})();
	 const parseExpression = (()=>{
	    const IS_IDENT_RE = /^(\-\-|[a-z\u0240-\uffff])/i;
	    const IS_OPERATOR_RE = /^([\*\+\/]|[\-]\s)/i;
	    const IS_EXPRESSION_END_RE = /^[\),]/;
	    const FUNCTION_ARGUMENTS_FIRST_TOKEN = '(';
	    const HEX_FIRST_TOKEN = '#';
	    return (inputString)=>{
	        const terms = [];
	        while(inputString.length){
	            inputString = inputString.trim();
	            if (IS_EXPRESSION_END_RE.test(inputString)) {
	                break;
	            } else if (inputString[0] === FUNCTION_ARGUMENTS_FIRST_TOKEN) {
	                const { nodes, remainingInput } = parseFunctionArguments(inputString);
	                inputString = remainingInput;
	                terms.push({
	                    type: 'function',
	                    name: {
	                        type: 'ident',
	                        value: 'calc'
	                    },
	                    arguments: nodes
	                });
	            } else if (IS_IDENT_RE.test(inputString)) {
	                const identParseResult = parseIdent(inputString);
	                const identNode = identParseResult.nodes[0];
	                inputString = identParseResult.remainingInput;
	                if (inputString[0] === FUNCTION_ARGUMENTS_FIRST_TOKEN) {
	                    const { nodes, remainingInput } = parseFunctionArguments(inputString);
	                    terms.push({
	                        type: 'function',
	                        name: identNode,
	                        arguments: nodes
	                    });
	                    inputString = remainingInput;
	                } else {
	                    terms.push(identNode);
	                }
	            } else if (IS_OPERATOR_RE.test(inputString)) {
	                terms.push({
	                    type: 'operator',
	                    value: inputString[0]
	                });
	                inputString = inputString.slice(1);
	            } else {
	                const { nodes, remainingInput } = inputString[0] === HEX_FIRST_TOKEN ? parseHex(inputString) : parseNumber(inputString);
	                if (nodes.length === 0) {
	                    break;
	                }
	                terms.push(nodes[0]);
	                inputString = remainingInput;
	            }
	        }
	        return {
	            nodes: [
	                {
	                    type: 'expression',
	                    terms
	                }
	            ],
	            remainingInput: inputString
	        };
	    };
	})();
	 const parseIdent = (()=>{
	    const NOT_IDENT_RE = /[^a-z0-9_\-\u0240-\uffff]/i;
	    return (inputString)=>{
	        const match = inputString.match(NOT_IDENT_RE);
	        const ident = match == null ? inputString : inputString.substr(0, match.index);
	        const remainingInput = match == null ? '' : inputString.substr(match.index);
	        return {
	            nodes: [
	                {
	                    type: 'ident',
	                    value: ident
	                }
	            ],
	            remainingInput
	        };
	    };
	})();
	 const parseNumber = (()=>{
	    const VALUE_RE = /[\+\-]?(\d+[\.]\d+|\d+|[\.]\d+)([eE][\+\-]?\d+)?/;
	    const UNIT_RE = /^[a-z%]+/i;
	    const ALLOWED_UNITS = /^(m|mm|cm|rad|deg|[%])$/;
	    return (inputString)=>{
	        const valueMatch = inputString.match(VALUE_RE);
	        const value = valueMatch == null ? '0' : valueMatch[0];
	        inputString = value == null ? inputString : inputString.slice(value.length);
	        const unitMatch = inputString.match(UNIT_RE);
	        let unit = unitMatch != null && unitMatch[0] !== '' ? unitMatch[0] : null;
	        const remainingInput = unitMatch == null ? inputString : inputString.slice(unit.length);
	        if (unit != null && !ALLOWED_UNITS.test(unit)) {
	            unit = null;
	        }
	        return {
	            nodes: [
	                {
	                    type: 'number',
	                    number: parseFloat(value) || 0,
	                    unit: unit
	                }
	            ],
	            remainingInput
	        };
	    };
	})();
	 const parseHex = (()=>{
	    const HEX_RE = /^[a-f0-9]*/i;
	    return (inputString)=>{
	        inputString = inputString.slice(1).trim();
	        const hexMatch = inputString.match(HEX_RE);
	        const nodes = hexMatch == null ? [] : [
	            {
	                type: 'hex',
	                value: hexMatch[0]
	            }
	        ];
	        return {
	            nodes,
	            remainingInput: hexMatch == null ? inputString : inputString.slice(hexMatch[0].length)
	        };
	    };
	})();
	 const parseFunctionArguments = (inputString)=>{
	    const expressionNodes = [];
	    inputString = inputString.slice(1).trim();
	    while(inputString.length){
	        const expressionParseResult = parseExpression(inputString);
	        expressionNodes.push(expressionParseResult.nodes[0]);
	        inputString = expressionParseResult.remainingInput.trim();
	        if (inputString[0] === ',') {
	            inputString = inputString.slice(1).trim();
	        } else if (inputString[0] === ')') {
	            inputString = inputString.slice(1);
	            break;
	        }
	    }
	    return {
	        nodes: expressionNodes,
	        remainingInput: inputString
	    };
	};
	const $visitedTypes = Symbol('visitedTypes');
	 class ASTWalker {
	 walk(ast, callback) {
	        const remaining = ast.slice();
	        while(remaining.length){
	            const next = remaining.shift();
	            if (this[$visitedTypes].indexOf(next.type) > -1) {
	                callback(next);
	            }
	            switch(next.type){
	                case 'expression':
	                    remaining.unshift(...next.terms);
	                    break;
	                case 'function':
	                    remaining.unshift(next.name, ...next.arguments);
	                    break;
	            }
	        }
	    }
	    constructor(visitedTypes){
	        this[$visitedTypes] = visitedTypes;
	    }
	}
	const ZERO = Object.freeze({
	    type: 'number',
	    number: 0,
	    unit: null
	});

	const degreesToRadians = (numberNode, fallbackRadianValue = 0)=>{
	    let { number, unit } = numberNode;
	    if (!isFinite(number)) {
	        number = fallbackRadianValue;
	        unit = 'rad';
	    } else if (numberNode.unit === 'rad' || numberNode.unit == null) {
	        return numberNode;
	    }
	    const valueIsDegrees = unit === 'deg' && number != null;
	    const value = valueIsDegrees ? number : 0;
	    const radians = value * Math.PI / 180;
	    return {
	        type: 'number',
	        number: radians,
	        unit: 'rad'
	    };
	};
	 const lengthToBaseMeters = (numberNode, fallbackMeterValue = 0)=>{
	    let { number, unit } = numberNode;
	    if (!isFinite(number)) {
	        number = fallbackMeterValue;
	        unit = 'm';
	    } else if (numberNode.unit === 'm') {
	        return numberNode;
	    }
	    let scale;
	    switch(unit){
	        default:
	            scale = 1;
	            break;
	        case 'cm':
	            scale = 1 / 100;
	            break;
	        case 'mm':
	            scale = 1 / 1000;
	            break;
	    }
	    const value = scale * number;
	    return {
	        type: 'number',
	        number: value,
	        unit: 'm'
	    };
	};
	 const normalizeUnit = (()=>{
	    const identity = (node)=>node;
	    const unitNormalizers = {
	        'rad': identity,
	        'deg': degreesToRadians,
	        'm': identity,
	        'mm': lengthToBaseMeters,
	        'cm': lengthToBaseMeters
	    };
	    return (node, fallback = ZERO)=>{
	        if (!isFinite(node.number)) {
	            node.number = fallback.number;
	            node.unit = fallback.unit;
	        }
	        const { unit } = node;
	        if (unit == null) {
	            return node;
	        }
	        const normalize = unitNormalizers[unit];
	        if (normalize == null) {
	            return fallback;
	        }
	        return normalize(node);
	    };
	})();

	var _a$6, _b$6, _c$4;
	const $evaluate = Symbol('evaluate');
	const $lastValue = Symbol('lastValue');
	 class Evaluator {
	 static evaluatableFor(node, basis = ZERO) {
	        if (node instanceof Evaluator) {
	            return node;
	        }
	        if (node.type === 'number') {
	            if (node.unit === '%') {
	                return new PercentageEvaluator(node, basis);
	            }
	            return node;
	        }
	        switch(node.name.value){
	            case 'calc':
	                return new CalcEvaluator(node, basis);
	            case 'env':
	                return new EnvEvaluator(node);
	        }
	        return ZERO;
	    }
	 static evaluate(evaluatable) {
	        if (evaluatable instanceof Evaluator) {
	            return evaluatable.evaluate();
	        }
	        return evaluatable;
	    }
	 static isConstant(evaluatable) {
	        if (evaluatable instanceof Evaluator) {
	            return evaluatable.isConstant;
	        }
	        return true;
	    }
	 static applyIntrinsics(evaluated, intrinsics) {
	        const { basis, keywords } = intrinsics;
	        const { auto } = keywords;
	        return basis.map((basisNode, index)=>{
	            const autoSubstituteNode = auto[index] == null ? basisNode : auto[index];
	            let evaluatedNode = evaluated[index] ? evaluated[index] : autoSubstituteNode;
	            if (evaluatedNode.type === 'ident') {
	                const keyword = evaluatedNode.value;
	                if (keyword in keywords) {
	                    evaluatedNode = keywords[keyword][index];
	                }
	            }
	            if (evaluatedNode == null || evaluatedNode.type === 'ident') {
	                evaluatedNode = autoSubstituteNode;
	            }
	            if (evaluatedNode.unit === '%') {
	                return numberNode(evaluatedNode.number / 100 * basisNode.number, basisNode.unit);
	            }
	            evaluatedNode = normalizeUnit(evaluatedNode, basisNode);
	            if (evaluatedNode.unit !== basisNode.unit) {
	                return basisNode;
	            }
	            return evaluatedNode;
	        });
	    }
	 get isConstant() {
	        return false;
	    }
	 evaluate() {
	        if (!this.isConstant || this[$lastValue] == null) {
	            this[$lastValue] = this[$evaluate]();
	        }
	        return this[$lastValue];
	    }
	    constructor(){
	        this[_a$6] = null;
	    }
	}
	_a$6 = $lastValue;
	const $percentage = Symbol('percentage');
	const $basis = Symbol('basis');
	 class PercentageEvaluator extends Evaluator {
	    get isConstant() {
	        return true;
	    }
	    [$evaluate]() {
	        return numberNode(this[$percentage].number / 100 * this[$basis].number, this[$basis].unit);
	    }
	    constructor(percentage, basis){
	        super();
	        this[$percentage] = percentage;
	        this[$basis] = basis;
	    }
	}
	const $identNode = Symbol('identNode');
	 class EnvEvaluator extends Evaluator {
	    get isConstant() {
	        return false;
	    }
	    [(_b$6 = $identNode, $evaluate)]() {
	        if (this[$identNode] != null) {
	            switch(this[$identNode].value){
	                case 'window-scroll-y':
	                    const verticalScrollPosition = window.pageYOffset;
	                    const verticalScrollMax = Math.max(document.body.scrollHeight, document.body.offsetHeight, document.documentElement.clientHeight, document.documentElement.scrollHeight, document.documentElement.offsetHeight);
	                    const scrollY = verticalScrollPosition / (verticalScrollMax - window.innerHeight) || 0;
	                    return {
	                        type: 'number',
	                        number: scrollY,
	                        unit: null
	                    };
	            }
	        }
	        return ZERO;
	    }
	    constructor(envFunction){
	        super();
	        this[_b$6] = null;
	        const identNode = envFunction.arguments.length ? envFunction.arguments[0].terms[0] : null;
	        if (identNode != null && identNode.type === 'ident') {
	            this[$identNode] = identNode;
	        }
	    }
	}
	const IS_MULTIPLICATION_RE = /[\*\/]/;
	const $evaluator = Symbol('evaluator');
	 class CalcEvaluator extends Evaluator {
	    get isConstant() {
	        return this[$evaluator] == null || Evaluator.isConstant(this[$evaluator]);
	    }
	    [(_c$4 = $evaluator, $evaluate)]() {
	        return this[$evaluator] != null ? Evaluator.evaluate(this[$evaluator]) : ZERO;
	    }
	    constructor(calcFunction, basis = ZERO){
	        super();
	        this[_c$4] = null;
	        if (calcFunction.arguments.length !== 1) {
	            return;
	        }
	        const terms = calcFunction.arguments[0].terms.slice();
	        const secondOrderTerms = [];
	        while(terms.length){
	            const term = terms.shift();
	            if (secondOrderTerms.length > 0) {
	                const previousTerm = secondOrderTerms[secondOrderTerms.length - 1];
	                if (previousTerm.type === 'operator' && IS_MULTIPLICATION_RE.test(previousTerm.value)) {
	                    const operator = secondOrderTerms.pop();
	                    const leftValue = secondOrderTerms.pop();
	                    if (leftValue == null) {
	                        return;
	                    }
	                    secondOrderTerms.push(new OperatorEvaluator(operator, Evaluator.evaluatableFor(leftValue, basis), Evaluator.evaluatableFor(term, basis)));
	                    continue;
	                }
	            }
	            secondOrderTerms.push(term.type === 'operator' ? term : Evaluator.evaluatableFor(term, basis));
	        }
	        while(secondOrderTerms.length > 2){
	            const [left, operator, right] = secondOrderTerms.splice(0, 3);
	            if (operator.type !== 'operator') {
	                return;
	            }
	            secondOrderTerms.unshift(new OperatorEvaluator(operator, Evaluator.evaluatableFor(left, basis), Evaluator.evaluatableFor(right, basis)));
	        }
	        if (secondOrderTerms.length === 1) {
	            this[$evaluator] = secondOrderTerms[0];
	        }
	    }
	}
	const $operator = Symbol('operator');
	const $left = Symbol('left');
	const $right = Symbol('right');
	 class OperatorEvaluator extends Evaluator {
	    get isConstant() {
	        return Evaluator.isConstant(this[$left]) && Evaluator.isConstant(this[$right]);
	    }
	    [$evaluate]() {
	        const leftNode = normalizeUnit(Evaluator.evaluate(this[$left]));
	        const rightNode = normalizeUnit(Evaluator.evaluate(this[$right]));
	        const { number: leftValue, unit: leftUnit } = leftNode;
	        const { number: rightValue, unit: rightUnit } = rightNode;
	        if (rightUnit != null && leftUnit != null && rightUnit != leftUnit) {
	            return ZERO;
	        }
	        const unit = leftUnit || rightUnit;
	        let value;
	        switch(this[$operator].value){
	            case '+':
	                value = leftValue + rightValue;
	                break;
	            case '-':
	                value = leftValue - rightValue;
	                break;
	            case '/':
	                value = leftValue / rightValue;
	                break;
	            case '*':
	                value = leftValue * rightValue;
	                break;
	            default:
	                return ZERO;
	        }
	        return {
	            type: 'number',
	            number: value,
	            unit
	        };
	    }
	    constructor(operator, left, right){
	        super();
	        this[$operator] = operator;
	        this[$left] = left;
	        this[$right] = right;
	    }
	}
	const $evaluatables = Symbol('evaluatables');
	const $intrinsics = Symbol('intrinsics');
	 class StyleEvaluator extends Evaluator {
	    get isConstant() {
	        for (const evaluatable of this[$evaluatables]){
	            if (!Evaluator.isConstant(evaluatable)) {
	                return false;
	            }
	        }
	        return true;
	    }
	    [$evaluate]() {
	        const evaluated = this[$evaluatables].map((evaluatable)=>Evaluator.evaluate(evaluatable));
	        return Evaluator.applyIntrinsics(evaluated, this[$intrinsics]).map((numberNode)=>numberNode.number);
	    }
	    constructor(expressions, intrinsics){
	        super();
	        this[$intrinsics] = intrinsics;
	        const firstExpression = expressions[0];
	        const terms = firstExpression != null ? firstExpression.terms : [];
	        this[$evaluatables] = intrinsics.basis.map((basisNode, index)=>{
	            const term = terms[index];
	            if (term == null) {
	                return {
	                    type: 'ident',
	                    value: 'auto'
	                };
	            }
	            if (term.type === 'ident') {
	                return term;
	            }
	            return Evaluator.evaluatableFor(term, basisNode);
	        });
	    }
	}

	var _a$5, _b$5, _c$3, _d$2;
	const $instances = Symbol('instances');
	const $activateListener = Symbol('activateListener');
	const $deactivateListener = Symbol('deactivateListener');
	const $notifyInstances = Symbol('notifyInstances');
	const $notify = Symbol('notify');
	const $scrollCallback = Symbol('callback');
	 class ScrollObserver {
	    static [$notifyInstances]() {
	        for (const instance of ScrollObserver[$instances]){
	            instance[$notify]();
	        }
	    }
	    static [(_a$5 = $instances, $activateListener)]() {
	        window.addEventListener('scroll', this[$notifyInstances], {
	            passive: true
	        });
	    }
	    static [$deactivateListener]() {
	        window.removeEventListener('scroll', this[$notifyInstances]);
	    }
	 observe() {
	        if (ScrollObserver[$instances].size === 0) {
	            ScrollObserver[$activateListener]();
	        }
	        ScrollObserver[$instances].add(this);
	    }
	 disconnect() {
	        ScrollObserver[$instances].delete(this);
	        if (ScrollObserver[$instances].size === 0) {
	            ScrollObserver[$deactivateListener]();
	        }
	    }
	    [$notify]() {
	        this[$scrollCallback]();
	    }
	    constructor(callback){
	        this[$scrollCallback] = callback;
	    }
	}
	ScrollObserver[_a$5] = new Set();
	const $computeStyleCallback = Symbol('computeStyleCallback');
	const $astWalker = Symbol('astWalker');
	const $dependencies = Symbol('dependencies');
	const $onScroll = Symbol('onScroll');
	 class StyleEffector {
	 observeEffectsFor(ast) {
	        const newDependencies = {};
	        const oldDependencies = this[$dependencies];
	        this[$astWalker].walk(ast, (functionNode)=>{
	            const { name } = functionNode;
	            const firstArgument = functionNode.arguments[0];
	            const firstTerm = firstArgument.terms[0];
	            if (name.value !== 'env' || firstTerm == null || firstTerm.type !== 'ident') {
	                return;
	            }
	            switch(firstTerm.value){
	                case 'window-scroll-y':
	                    if (newDependencies['window-scroll'] == null) {
	                        const observer = 'window-scroll' in oldDependencies ? oldDependencies['window-scroll'] : new ScrollObserver(this[$onScroll]);
	                        observer.observe();
	                        delete oldDependencies['window-scroll'];
	                        newDependencies['window-scroll'] = observer;
	                    }
	                    break;
	            }
	        });
	        for(const environmentState in oldDependencies){
	            const observer = oldDependencies[environmentState];
	            observer.disconnect();
	        }
	        this[$dependencies] = newDependencies;
	    }
	 dispose() {
	        for(const environmentState in this[$dependencies]){
	            const observer = this[$dependencies][environmentState];
	            observer.disconnect();
	        }
	    }
	    constructor(callback){
	        this[_b$5] = {};
	        this[_c$3] = new ASTWalker([
	            'function'
	        ]);
	        this[_d$2] = ()=>{
	            this[$computeStyleCallback]({
	                relatedState: 'window-scroll'
	            });
	        };
	        this[$computeStyleCallback] = callback;
	    }
	}
	_b$5 = $dependencies, _c$3 = $astWalker, _d$2 = $onScroll;

	const style = (config)=>{
	    const observeEffects = config.observeEffects || false;
	    const getIntrinsics = config.intrinsics instanceof Function ? config.intrinsics : ()=>config.intrinsics;
	    return (proto, propertyName)=>{
	        const originalUpdated = proto.updated;
	        const originalConnectedCallback = proto.connectedCallback;
	        const originalDisconnectedCallback = proto.disconnectedCallback;
	        const $styleEffector = Symbol(`${propertyName}StyleEffector`);
	        const $styleEvaluator = Symbol(`${propertyName}StyleEvaluator`);
	        const $updateEvaluator = Symbol(`${propertyName}UpdateEvaluator`);
	        const $evaluateAndSync = Symbol(`${propertyName}EvaluateAndSync`);
	        Object.defineProperties(proto, {
	            [$styleEffector]: {
	                value: null,
	                writable: true
	            },
	            [$styleEvaluator]: {
	                value: null,
	                writable: true
	            },
	            [$updateEvaluator]: {
	                value: function() {
	                    const ast = parseExpressions(this[propertyName]);
	                    this[$styleEvaluator] = new StyleEvaluator(ast, getIntrinsics(this));
	                    if (this[$styleEffector] == null && observeEffects) {
	                        this[$styleEffector] = new StyleEffector(()=>this[$evaluateAndSync]());
	                    }
	                    if (this[$styleEffector] != null) {
	                        this[$styleEffector].observeEffectsFor(ast);
	                    }
	                }
	            },
	            [$evaluateAndSync]: {
	                value: function() {
	                    if (this[$styleEvaluator] == null) {
	                        return;
	                    }
	                    const result = this[$styleEvaluator].evaluate();
	                    this[config.updateHandler](result);
	                }
	            },
	            updated: {
	                value: function(changedProperties) {
	                    if (changedProperties.has(propertyName)) {
	                        this[$updateEvaluator]();
	                        this[$evaluateAndSync]();
	                    }
	                    originalUpdated.call(this, changedProperties);
	                }
	            },
	            connectedCallback: {
	                value: function() {
	                    originalConnectedCallback.call(this);
	                    this.requestUpdate(propertyName, this[propertyName]);
	                }
	            },
	            disconnectedCallback: {
	                value: function() {
	                    originalDisconnectedCallback.call(this);
	                    if (this[$styleEffector] != null) {
	                        this[$styleEffector].dispose();
	                        this[$styleEffector] = null;
	                    }
	                }
	            }
	        });
	    };
	};

	const easeInOutQuad = (t)=>t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
	 const interpolate = (start, end, ease = easeInOutQuad)=>(time)=>start + (end - start) * ease(time);
	 const sequence = (tracks, weights)=>{
	    const cumulativeSum = (sum)=>(value)=>sum += value;
	    const times = weights.map(cumulativeSum(0));
	    return (time)=>{
	        time = clamp(time, 0, 1);
	        time *= times[times.length - 1];
	        const i = times.findIndex((val)=>val >= time);
	        const start = i < 1 ? 0 : times[i - 1];
	        const end = times[i];
	        return tracks[i]((time - start) / (end - start));
	    };
	};
	 const timeline = (path)=>{
	    const tracks = [];
	    const weights = [];
	    let lastValue = path.initialValue;
	    for(let i = 0; i < path.keyframes.length; ++i){
	        const keyframe = path.keyframes[i];
	        const { value, frames } = keyframe;
	        const ease = keyframe.ease || easeInOutQuad;
	        const track = interpolate(lastValue, value, ease);
	        tracks.push(track);
	        weights.push(frames);
	        lastValue = value;
	    }
	    return sequence(tracks, weights);
	};

	var __decorate$6 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	const PROMPT_ANIMATION_TIME = 5000;
	const wiggle = timeline({
	    initialValue: 0,
	    keyframes: [
	        {
	            frames: 5,
	            value: -1
	        },
	        {
	            frames: 1,
	            value: -1
	        },
	        {
	            frames: 8,
	            value: 1
	        },
	        {
	            frames: 1,
	            value: 1
	        },
	        {
	            frames: 5,
	            value: 0
	        },
	        {
	            frames: 18,
	            value: 0
	        }
	    ]
	});
	const fade = timeline({
	    initialValue: 0,
	    keyframes: [
	        {
	            frames: 1,
	            value: 1
	        },
	        {
	            frames: 5,
	            value: 1
	        },
	        {
	            frames: 1,
	            value: 0
	        },
	        {
	            frames: 6,
	            value: 0
	        }
	    ]
	});
	const DEFAULT_FOV_DEG = 30;
	const DEFAULT_MIN_FOV_DEG = 12;
	const DEFAULT_CAMERA_ORBIT = '0deg 75deg 105%';
	const DEFAULT_CAMERA_TARGET = 'auto auto auto';
	const DEFAULT_FIELD_OF_VIEW = 'auto';
	const MINIMUM_RADIUS_RATIO = 2.2;
	const AZIMUTHAL_QUADRANT_LABELS = [
	    'front',
	    'right',
	    'back',
	    'left'
	];
	const POLAR_TRIENT_LABELS = [
	    'upper-',
	    '',
	    'lower-'
	];
	const DEFAULT_INTERACTION_PROMPT_THRESHOLD = 3000;
	const INTERACTION_PROMPT = '. Use mouse, touch or arrow keys to move.';
	const InteractionPromptStrategy = {
	    AUTO: 'auto'};
	const InteractionPromptStyle = {
	    BASIC: 'basic',
	    WIGGLE: 'wiggle'
	};
	const TouchAction = {
	    NONE: 'none'
	};
	const fieldOfViewIntrinsics = ()=>{
	    return {
	        basis: [
	            degreesToRadians(numberNode(DEFAULT_FOV_DEG, 'deg'))
	        ],
	        keywords: {
	            auto: [
	                null
	            ]
	        }
	    };
	};
	const minFieldOfViewIntrinsics = ()=>{
	    return {
	        basis: [
	            degreesToRadians(numberNode(DEFAULT_MIN_FOV_DEG, 'deg'))
	        ],
	        keywords: {
	            auto: [
	                null
	            ]
	        }
	    };
	};
	const cameraOrbitIntrinsics = (()=>{
	    const defaultTerms = parseExpressions(DEFAULT_CAMERA_ORBIT)[0].terms;
	    const theta = normalizeUnit(defaultTerms[0]);
	    const phi = normalizeUnit(defaultTerms[1]);
	    return (element)=>{
	        const radius = element[$scene].idealCameraDistance();
	        return {
	            basis: [
	                theta,
	                phi,
	                numberNode(radius, 'm')
	            ],
	            keywords: {
	                auto: [
	                    null,
	                    null,
	                    numberNode(105, '%')
	                ]
	            }
	        };
	    };
	})();
	const minCameraOrbitIntrinsics = (element)=>{
	    const radius = MINIMUM_RADIUS_RATIO * element[$scene].boundingSphere.radius;
	    return {
	        basis: [
	            numberNode(-Infinity, 'rad'),
	            numberNode(0, 'rad'),
	            numberNode(radius, 'm')
	        ],
	        keywords: {
	            auto: [
	                null,
	                null,
	                null
	            ]
	        }
	    };
	};
	const maxCameraOrbitIntrinsics = (element)=>{
	    const orbitIntrinsics = cameraOrbitIntrinsics(element);
	    const evaluator = new StyleEvaluator([], orbitIntrinsics);
	    const defaultRadius = evaluator.evaluate()[2];
	    return {
	        basis: [
	            numberNode(Infinity, 'rad'),
	            numberNode(Math.PI, 'rad'),
	            numberNode(defaultRadius, 'm')
	        ],
	        keywords: {
	            auto: [
	                null,
	                null,
	                null
	            ]
	        }
	    };
	};
	const cameraTargetIntrinsics = (element)=>{
	    const center = element[$scene].boundingBox.getCenter(new Vector3());
	    return {
	        basis: [
	            numberNode(center.x, 'm'),
	            numberNode(center.y, 'm'),
	            numberNode(center.z, 'm')
	        ],
	        keywords: {
	            auto: [
	                null,
	                null,
	                null
	            ]
	        }
	    };
	};
	const HALF_PI = Math.PI / 2.0;
	const THIRD_PI = Math.PI / 3.0;
	const QUARTER_PI = HALF_PI / 2.0;
	const TAU = 2.0 * Math.PI;
	const $controls = Symbol('controls');
	const $panElement = Symbol('panElement');
	const $promptElement = Symbol('promptElement');
	const $promptAnimatedContainer = Symbol('promptAnimatedContainer');
	const $fingerAnimatedContainers = Symbol('fingerAnimatedContainers');
	const $deferInteractionPrompt = Symbol('deferInteractionPrompt');
	const $updateAria = Symbol('updateAria');
	const $a11y = Symbol('a11y');
	const $updateA11y = Symbol('updateA11y');
	const $updateCameraForRadius = Symbol('updateCameraForRadius');
	const $cancelPrompts = Symbol('cancelPrompts');
	const $onChange = Symbol('onChange');
	const $onPointerChange = Symbol('onPointerChange');
	const $waitingToPromptUser = Symbol('waitingToPromptUser');
	const $userHasInteracted = Symbol('userHasInteracted');
	const $promptElementVisibleTime = Symbol('promptElementVisibleTime');
	const $lastPromptOffset = Symbol('lastPromptOffset');
	const $cancellationSource = Symbol('cancellationSource');
	const $lastSpherical = Symbol('lastSpherical');
	const $jumpCamera = Symbol('jumpCamera');
	const $initialized = Symbol('initialized');
	const $maintainThetaPhi = Symbol('maintainThetaPhi');
	const $syncCameraOrbit = Symbol('syncCameraOrbit');
	const $syncFieldOfView = Symbol('syncFieldOfView');
	const $syncCameraTarget = Symbol('syncCameraTarget');
	const $syncMinCameraOrbit = Symbol('syncMinCameraOrbit');
	const $syncMaxCameraOrbit = Symbol('syncMaxCameraOrbit');
	const $syncMinFieldOfView = Symbol('syncMinFieldOfView');
	const $syncMaxFieldOfView = Symbol('syncMaxFieldOfView');
	const ControlsMixin = (ModelViewerElement)=>{
	    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
	    class ControlsModelViewerElement extends ModelViewerElement {
	        get inputSensitivity() {
	            return this[$controls].inputSensitivity;
	        }
	        set inputSensitivity(value) {
	            this[$controls].inputSensitivity = value;
	        }
	        getCameraOrbit() {
	            const { theta, phi, radius } = this[$lastSpherical];
	            return {
	                theta,
	                phi,
	                radius,
	                toString () {
	                    return `${this.theta}rad ${this.phi}rad ${this.radius}m`;
	                }
	            };
	        }
	        getCameraTarget() {
	            return toVector3D(this[$renderer].isPresenting ? this[$renderer].arRenderer.target : this[$scene].getDynamicTarget());
	        }
	        getFieldOfView() {
	            return this[$controls].getFieldOfView();
	        }
	        getMinimumFieldOfView() {
	            return this[$controls].options.minimumFieldOfView;
	        }
	        getMaximumFieldOfView() {
	            return this[$controls].options.maximumFieldOfView;
	        }
	        getIdealAspect() {
	            return this[$scene].idealAspect;
	        }
	        jumpCameraToGoal() {
	            this[$jumpCamera] = true;
	            this.requestUpdate($jumpCamera, false);
	        }
	        resetInteractionPrompt() {
	            this[$lastPromptOffset] = 0;
	            this[$promptElementVisibleTime] = Infinity;
	            this[$userHasInteracted] = false;
	            this[$waitingToPromptUser] = this.interactionPrompt === InteractionPromptStrategy.AUTO && this.cameraControls;
	        }
	        zoom(keyPresses) {
	            const event = new WheelEvent('wheel', {
	                deltaY: -30 * keyPresses
	            });
	            this[$userInputElement].dispatchEvent(event);
	        }
	        connectedCallback() {
	            super.connectedCallback();
	            this[$controls].addEventListener('user-interaction', this[$cancelPrompts]);
	            this[$controls].addEventListener('pointer-change-start', this[$onPointerChange]);
	            this[$controls].addEventListener('pointer-change-end', this[$onPointerChange]);
	        }
	        disconnectedCallback() {
	            super.disconnectedCallback();
	            this[$controls].removeEventListener('user-interaction', this[$cancelPrompts]);
	            this[$controls].removeEventListener('pointer-change-start', this[$onPointerChange]);
	            this[$controls].removeEventListener('pointer-change-end', this[$onPointerChange]);
	        }
	        updated(changedProperties) {
	            super.updated(changedProperties);
	            const controls = this[$controls];
	            const scene = this[$scene];
	            if (changedProperties.has('cameraControls')) {
	                if (this.cameraControls) {
	                    controls.enableInteraction();
	                    if (this.interactionPrompt === InteractionPromptStrategy.AUTO) {
	                        this[$waitingToPromptUser] = true;
	                    }
	                } else {
	                    controls.disableInteraction();
	                    this[$deferInteractionPrompt]();
	                }
	                this[$userInputElement].setAttribute('aria-label', this[$ariaLabel]);
	            }
	            if (changedProperties.has('disableZoom')) {
	                controls.disableZoom = this.disableZoom;
	            }
	            if (changedProperties.has('disablePan')) {
	                controls.enablePan = !this.disablePan;
	            }
	            if (changedProperties.has('disableTap')) {
	                controls.enableTap = !this.disableTap;
	            }
	            if (changedProperties.has('interactionPrompt') || changedProperties.has('cameraControls') || changedProperties.has('src')) {
	                if (this.interactionPrompt === InteractionPromptStrategy.AUTO && this.cameraControls && !this[$userHasInteracted]) {
	                    this[$waitingToPromptUser] = true;
	                } else {
	                    this[$deferInteractionPrompt]();
	                }
	            }
	            if (changedProperties.has('interactionPromptStyle')) {
	                this[$promptAnimatedContainer].style.opacity = this.interactionPromptStyle == InteractionPromptStyle.BASIC ? '1' : '0';
	            }
	            if (changedProperties.has('touchAction')) {
	                const touchAction = this.touchAction;
	                controls.applyOptions({
	                    touchAction
	                });
	                controls.updateTouchActionStyle();
	            }
	            if (changedProperties.has('orbitSensitivity')) {
	                controls.orbitSensitivity = this.orbitSensitivity;
	            }
	            if (changedProperties.has('zoomSensitivity')) {
	                controls.zoomSensitivity = this.zoomSensitivity;
	            }
	            if (changedProperties.has('panSensitivity')) {
	                controls.panSensitivity = this.panSensitivity;
	            }
	            if (changedProperties.has('interpolationDecay')) {
	                controls.setDamperDecayTime(this.interpolationDecay);
	                scene.setTargetDamperDecayTime(this.interpolationDecay);
	            }
	            if (changedProperties.has('a11y')) {
	                this[$updateA11y]();
	            }
	            if (this[$jumpCamera] === true) {
	                Promise.resolve().then(()=>{
	                    controls.jumpToGoal();
	                    scene.jumpToGoal();
	                    this[$onChange]();
	                    this[$jumpCamera] = false;
	                });
	            }
	        }
	        async updateFraming() {
	            const scene = this[$scene];
	            const oldFramedFoV = scene.adjustedFoV(scene.framedFoVDeg);
	            await scene.updateFraming();
	            const newFramedFoV = scene.adjustedFoV(scene.framedFoVDeg);
	            const zoom = this[$controls].getFieldOfView() / oldFramedFoV;
	            this[$controls].setFieldOfView(newFramedFoV * zoom);
	            this[$maintainThetaPhi] = true;
	            this.requestUpdate('maxFieldOfView');
	            this.requestUpdate('fieldOfView');
	            this.requestUpdate('minCameraOrbit');
	            this.requestUpdate('maxCameraOrbit');
	            this.requestUpdate('cameraOrbit');
	            await this.updateComplete;
	        }
	        interact(duration, finger0, finger1) {
	            const inputElement = this[$userInputElement];
	            const fingerElements = this[$fingerAnimatedContainers];
	            if (fingerElements[0].style.opacity === '1') {
	                console.warn('interact() failed because an existing interaction is running.');
	                return;
	            }
	            const xy = new Array();
	            xy.push({
	                x: timeline(finger0.x),
	                y: timeline(finger0.y)
	            });
	            const positions = [
	                {
	                    x: xy[0].x(0),
	                    y: xy[0].y(0)
	                }
	            ];
	            if (finger1 != null) {
	                xy.push({
	                    x: timeline(finger1.x),
	                    y: timeline(finger1.y)
	                });
	                positions.push({
	                    x: xy[1].x(0),
	                    y: xy[1].y(0)
	                });
	            }
	            let startTime = performance.now();
	            const { width, height } = this[$scene];
	            const rect = this.getBoundingClientRect();
	            const dispatchTouches = (type)=>{
	                for (const [i, position] of positions.entries()){
	                    const { style } = fingerElements[i];
	                    style.transform = `translateX(${width * position.x}px) translateY(${height * position.y}px)`;
	                    if (type === 'pointerdown') {
	                        style.opacity = '1';
	                    } else if (type === 'pointerup') {
	                        style.opacity = '0';
	                    }
	                    const init = {
	                        pointerId: i - 5678,
	                        pointerType: 'touch',
	                        target: inputElement,
	                        clientX: width * position.x + rect.x,
	                        clientY: height * position.y + rect.y,
	                        altKey: true
	                    };
	                    inputElement.dispatchEvent(new PointerEvent(type, init));
	                }
	            };
	            const moveTouches = ()=>{
	                const changeSource = this[$cancellationSource];
	                if (changeSource !== ChangeSource.AUTOMATIC || !inputElement.isConnected) {
	                    for (const fingerElement of this[$fingerAnimatedContainers]){
	                        fingerElement.style.opacity = '0';
	                    }
	                    dispatchTouches('pointercancel');
	                    this.dispatchEvent(new CustomEvent('interact-stopped', {
	                        detail: {
	                            source: changeSource
	                        }
	                    }));
	                    document.removeEventListener('visibilitychange', onVisibilityChange);
	                    return;
	                }
	                const time = Math.min(1, (performance.now() - startTime) / duration);
	                for (const [i, position] of positions.entries()){
	                    position.x = xy[i].x(time);
	                    position.y = xy[i].y(time);
	                }
	                dispatchTouches('pointermove');
	                if (time < 1) {
	                    requestAnimationFrame(moveTouches);
	                } else {
	                    dispatchTouches('pointerup');
	                    this.dispatchEvent(new CustomEvent('interact-stopped', {
	                        detail: {
	                            source: ChangeSource.AUTOMATIC
	                        }
	                    }));
	                    document.removeEventListener('visibilitychange', onVisibilityChange);
	                }
	            };
	            const onVisibilityChange = ()=>{
	                let elapsed = 0;
	                if (document.visibilityState === 'hidden') {
	                    elapsed = performance.now() - startTime;
	                } else {
	                    startTime = performance.now() - elapsed;
	                }
	            };
	            document.addEventListener('visibilitychange', onVisibilityChange);
	            dispatchTouches('pointerdown');
	            this[$cancellationSource] = ChangeSource.AUTOMATIC;
	            requestAnimationFrame(moveTouches);
	        }
	        [(_a = $promptElement, _b = $promptAnimatedContainer, _c = $fingerAnimatedContainers, _d = $panElement, _e = $lastPromptOffset, _f = $promptElementVisibleTime, _g = $userHasInteracted, _h = $waitingToPromptUser, _j = $cancellationSource, _k = $controls, _l = $lastSpherical, _m = $jumpCamera, _o = $initialized, _p = $maintainThetaPhi, _q = $a11y, $syncFieldOfView)](style) {
	            const controls = this[$controls];
	            const scene = this[$scene];
	            scene.framedFoVDeg = style[0] * 180 / Math.PI;
	            controls.changeSource = ChangeSource.NONE;
	            controls.setFieldOfView(scene.adjustedFoV(scene.framedFoVDeg));
	            this[$cancelPrompts]();
	        }
	        [$syncCameraOrbit](style) {
	            const controls = this[$controls];
	            if (this[$maintainThetaPhi]) {
	                const { theta, phi } = this.getCameraOrbit();
	                style[0] = theta;
	                style[1] = phi;
	                this[$maintainThetaPhi] = false;
	            }
	            controls.changeSource = ChangeSource.NONE;
	            controls.setOrbit(style[0], style[1], style[2]);
	            this[$cancelPrompts]();
	        }
	        [$syncMinCameraOrbit](style) {
	            this[$controls].applyOptions({
	                minimumAzimuthalAngle: style[0],
	                minimumPolarAngle: style[1],
	                minimumRadius: style[2]
	            });
	            this.jumpCameraToGoal();
	        }
	        [$syncMaxCameraOrbit](style) {
	            this[$controls].applyOptions({
	                maximumAzimuthalAngle: style[0],
	                maximumPolarAngle: style[1],
	                maximumRadius: style[2]
	            });
	            this[$updateCameraForRadius](style[2]);
	            this.jumpCameraToGoal();
	        }
	        [$syncMinFieldOfView](style) {
	            this[$controls].applyOptions({
	                minimumFieldOfView: style[0] * 180 / Math.PI
	            });
	            this.jumpCameraToGoal();
	        }
	        [$syncMaxFieldOfView](style) {
	            const fov = this[$scene].adjustedFoV(style[0] * 180 / Math.PI);
	            this[$controls].applyOptions({
	                maximumFieldOfView: fov
	            });
	            this.jumpCameraToGoal();
	        }
	        [$syncCameraTarget](style) {
	            const [x, y, z] = style;
	            if (!this[$renderer].arRenderer.isPresenting) {
	                this[$scene].setTarget(x, y, z);
	            }
	            this[$controls].changeSource = ChangeSource.NONE;
	            this[$renderer].arRenderer.updateTarget();
	            this[$cancelPrompts]();
	        }
	        [$tick](time, delta) {
	            super[$tick](time, delta);
	            if (this[$renderer].isPresenting || !this[$getModelIsVisible]()) {
	                return;
	            }
	            const controls = this[$controls];
	            const scene = this[$scene];
	            const now = performance.now();
	            if (this[$waitingToPromptUser]) {
	                if (this.loaded && now > this[$loadedTime] + this.interactionPromptThreshold) {
	                    this[$waitingToPromptUser] = false;
	                    this[$promptElementVisibleTime] = now;
	                    this[$promptElement].classList.add('visible');
	                }
	            }
	            if (isFinite(this[$promptElementVisibleTime]) && this.interactionPromptStyle === InteractionPromptStyle.WIGGLE) {
	                const animationTime = (now - this[$promptElementVisibleTime]) / PROMPT_ANIMATION_TIME % 1;
	                const offset = wiggle(animationTime);
	                const opacity = fade(animationTime);
	                this[$promptAnimatedContainer].style.opacity = `${opacity}`;
	                if (offset !== this[$lastPromptOffset]) {
	                    const xOffset = offset * scene.width * 0.05;
	                    const deltaTheta = (offset - this[$lastPromptOffset]) * Math.PI / 16;
	                    this[$promptAnimatedContainer].style.transform = `translateX(${xOffset}px)`;
	                    controls.changeSource = ChangeSource.AUTOMATIC;
	                    controls.adjustOrbit(deltaTheta, 0, 0);
	                    this[$lastPromptOffset] = offset;
	                }
	            }
	            const cameraMoved = controls.update(time, delta);
	            const targetMoved = scene.updateTarget(delta);
	            if (cameraMoved || targetMoved) {
	                this[$onChange]();
	            }
	        }
	        [$deferInteractionPrompt]() {
	            this[$waitingToPromptUser] = false;
	            this[$promptElement].classList.remove('visible');
	            this[$promptElementVisibleTime] = Infinity;
	        }
	 [$updateCameraForRadius](radius) {
	            const maximumRadius = Math.max(this[$scene].farRadius(), radius);
	            const near = 0;
	            const far = Math.abs(2 * maximumRadius);
	            this[$controls].updateNearFar(near, far);
	        }
	        [$updateAria]() {
	            const { theta, phi } = this[$controls].getCameraSpherical(this[$lastSpherical]);
	            const azimuthalQuadrant = (4 + Math.floor((theta % TAU + QUARTER_PI) / HALF_PI)) % 4;
	            const polarTrient = Math.floor(phi / THIRD_PI);
	            const azimuthalQuadrantLabel = AZIMUTHAL_QUADRANT_LABELS[azimuthalQuadrant];
	            const polarTrientLabel = POLAR_TRIENT_LABELS[polarTrient];
	            const position = `${polarTrientLabel}${azimuthalQuadrantLabel}`;
	            const key = position;
	            if (key in this[$a11y]) {
	                this[$updateStatus](this[$a11y][key]);
	            } else {
	                this[$updateStatus](`View from stage ${position}`);
	            }
	        }
	        get [$ariaLabel]() {
	            let interactionPrompt = INTERACTION_PROMPT;
	            if ('interaction-prompt' in this[$a11y]) {
	                interactionPrompt = `. ${this[$a11y]['interaction-prompt']}`;
	            }
	            return super[$ariaLabel].replace(/\.$/, '') + (this.cameraControls ? interactionPrompt : '');
	        }
	        async [$onResize](event) {
	            const controls = this[$controls];
	            const scene = this[$scene];
	            const oldFramedFoV = scene.adjustedFoV(scene.framedFoVDeg);
	            super[$onResize](event);
	            const fovRatio = scene.adjustedFoV(scene.framedFoVDeg) / oldFramedFoV;
	            const fov = controls.getFieldOfView() * (isFinite(fovRatio) ? fovRatio : 1);
	            controls.updateAspect(this[$scene].aspect);
	            this.requestUpdate('maxFieldOfView', this.maxFieldOfView);
	            await this.updateComplete;
	            this[$controls].setFieldOfView(fov);
	            this.jumpCameraToGoal();
	        }
	        [$onModelLoad]() {
	            super[$onModelLoad]();
	            if (this[$initialized]) {
	                this[$maintainThetaPhi] = true;
	            } else {
	                this[$initialized] = true;
	            }
	            this.requestUpdate('maxFieldOfView', this.maxFieldOfView);
	            this.requestUpdate('fieldOfView', this.fieldOfView);
	            this.requestUpdate('minCameraOrbit', this.minCameraOrbit);
	            this.requestUpdate('maxCameraOrbit', this.maxCameraOrbit);
	            this.requestUpdate('cameraOrbit', this.cameraOrbit);
	            this.requestUpdate('cameraTarget', this.cameraTarget);
	            this.jumpCameraToGoal();
	        }
	        [(_r = $cancelPrompts, _s = $onChange, _t = $onPointerChange, $updateA11y)]() {
	            if (typeof this.a11y === 'string') {
	                if (this.a11y.startsWith('{')) {
	                    try {
	                        this[$a11y] = JSON.parse(this.a11y);
	                    } catch (error) {
	                        console.warn('Error parsing a11y JSON:', error);
	                    }
	                } else if (this.a11y.length > 0) {
	                    console.warn('Error not supported format, should be a JSON string:', this.a11y);
	                } else {
	                    this[$a11y] = {};
	                }
	            } else if (typeof this.a11y === 'object' && this.a11y != null) {
	                this[$a11y] = Object.assign({}, this.a11y);
	            } else {
	                this[$a11y] = {};
	            }
	            this[$userInputElement].setAttribute('aria-label', this[$ariaLabel]);
	        }
	        constructor(){
	            super(...arguments);
	            this.cameraControls = false;
	            this.cameraOrbit = DEFAULT_CAMERA_ORBIT;
	            this.cameraTarget = DEFAULT_CAMERA_TARGET;
	            this.fieldOfView = DEFAULT_FIELD_OF_VIEW;
	            this.minCameraOrbit = 'auto';
	            this.maxCameraOrbit = 'auto';
	            this.minFieldOfView = 'auto';
	            this.maxFieldOfView = 'auto';
	            this.interactionPromptThreshold = DEFAULT_INTERACTION_PROMPT_THRESHOLD;
	            this.interactionPrompt = InteractionPromptStrategy.AUTO;
	            this.interactionPromptStyle = InteractionPromptStyle.WIGGLE;
	            this.orbitSensitivity = 1;
	            this.zoomSensitivity = 1;
	            this.panSensitivity = 1;
	            this.touchAction = TouchAction.NONE;
	            this.disableZoom = false;
	            this.disablePan = false;
	            this.disableTap = false;
	            this.interpolationDecay = DECAY_MILLISECONDS;
	            this.a11y = null;
	            this[_a] = this.shadowRoot.querySelector('.interaction-prompt');
	            this[_b] = this.shadowRoot.querySelector('#prompt');
	            this[_c] = [
	                this.shadowRoot.querySelector('#finger0'),
	                this.shadowRoot.querySelector('#finger1')
	            ];
	            this[_d] = this.shadowRoot.querySelector('.pan-target');
	            this[_e] = 0;
	            this[_f] = Infinity;
	            this[_g] = false;
	            this[_h] = false;
	            this[_j] = ChangeSource.AUTOMATIC;
	            this[_k] = new SmoothControls(this[$scene].camera, this[$userInputElement], this[$scene]);
	            this[_l] = new Spherical();
	            this[_m] = false;
	            this[_o] = false;
	            this[_p] = false;
	            this[_q] = {};
	            this[_r] = ()=>{
	                const source = this[$controls].changeSource;
	                this[$cancellationSource] = source;
	                if (source === ChangeSource.USER_INTERACTION) {
	                    this[$userHasInteracted] = true;
	                    this[$deferInteractionPrompt]();
	                }
	            };
	            this[_s] = ()=>{
	                this[$updateAria]();
	                this[$needsRender]();
	                const source = this[$controls].changeSource;
	                this.dispatchEvent(new CustomEvent('camera-change', {
	                    detail: {
	                        source
	                    }
	                }));
	            };
	            this[_t] = (event)=>{
	                this[$container].classList.toggle('pointer-tumbling', event.type === 'pointer-change-start');
	            };
	        }
	    }
	    __decorate$6([
	        n$2({
	            type: Boolean,
	            attribute: 'camera-controls'
	        })
	    ], ControlsModelViewerElement.prototype, "cameraControls", void 0);
	    __decorate$6([
	        style({
	            intrinsics: cameraOrbitIntrinsics,
	            observeEffects: true,
	            updateHandler: $syncCameraOrbit
	        }),
	        n$2({
	            type: String,
	            attribute: 'camera-orbit',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "cameraOrbit", void 0);
	    __decorate$6([
	        style({
	            intrinsics: cameraTargetIntrinsics,
	            observeEffects: true,
	            updateHandler: $syncCameraTarget
	        }),
	        n$2({
	            type: String,
	            attribute: 'camera-target',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "cameraTarget", void 0);
	    __decorate$6([
	        style({
	            intrinsics: fieldOfViewIntrinsics,
	            observeEffects: true,
	            updateHandler: $syncFieldOfView
	        }),
	        n$2({
	            type: String,
	            attribute: 'field-of-view',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "fieldOfView", void 0);
	    __decorate$6([
	        style({
	            intrinsics: minCameraOrbitIntrinsics,
	            updateHandler: $syncMinCameraOrbit
	        }),
	        n$2({
	            type: String,
	            attribute: 'min-camera-orbit',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "minCameraOrbit", void 0);
	    __decorate$6([
	        style({
	            intrinsics: maxCameraOrbitIntrinsics,
	            updateHandler: $syncMaxCameraOrbit
	        }),
	        n$2({
	            type: String,
	            attribute: 'max-camera-orbit',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "maxCameraOrbit", void 0);
	    __decorate$6([
	        style({
	            intrinsics: minFieldOfViewIntrinsics,
	            updateHandler: $syncMinFieldOfView
	        }),
	        n$2({
	            type: String,
	            attribute: 'min-field-of-view',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "minFieldOfView", void 0);
	    __decorate$6([
	        style({
	            intrinsics: fieldOfViewIntrinsics,
	            updateHandler: $syncMaxFieldOfView
	        }),
	        n$2({
	            type: String,
	            attribute: 'max-field-of-view',
	            hasChanged: ()=>true
	        })
	    ], ControlsModelViewerElement.prototype, "maxFieldOfView", void 0);
	    __decorate$6([
	        n$2({
	            type: Number,
	            attribute: 'interaction-prompt-threshold'
	        })
	    ], ControlsModelViewerElement.prototype, "interactionPromptThreshold", void 0);
	    __decorate$6([
	        n$2({
	            type: String,
	            attribute: 'interaction-prompt'
	        })
	    ], ControlsModelViewerElement.prototype, "interactionPrompt", void 0);
	    __decorate$6([
	        n$2({
	            type: String,
	            attribute: 'interaction-prompt-style'
	        })
	    ], ControlsModelViewerElement.prototype, "interactionPromptStyle", void 0);
	    __decorate$6([
	        n$2({
	            type: Number,
	            attribute: 'orbit-sensitivity'
	        })
	    ], ControlsModelViewerElement.prototype, "orbitSensitivity", void 0);
	    __decorate$6([
	        n$2({
	            type: Number,
	            attribute: 'zoom-sensitivity'
	        })
	    ], ControlsModelViewerElement.prototype, "zoomSensitivity", void 0);
	    __decorate$6([
	        n$2({
	            type: Number,
	            attribute: 'pan-sensitivity'
	        })
	    ], ControlsModelViewerElement.prototype, "panSensitivity", void 0);
	    __decorate$6([
	        n$2({
	            type: String,
	            attribute: 'touch-action'
	        })
	    ], ControlsModelViewerElement.prototype, "touchAction", void 0);
	    __decorate$6([
	        n$2({
	            type: Boolean,
	            attribute: 'disable-zoom'
	        })
	    ], ControlsModelViewerElement.prototype, "disableZoom", void 0);
	    __decorate$6([
	        n$2({
	            type: Boolean,
	            attribute: 'disable-pan'
	        })
	    ], ControlsModelViewerElement.prototype, "disablePan", void 0);
	    __decorate$6([
	        n$2({
	            type: Boolean,
	            attribute: 'disable-tap'
	        })
	    ], ControlsModelViewerElement.prototype, "disableTap", void 0);
	    __decorate$6([
	        n$2({
	            type: Number,
	            attribute: 'interpolation-decay'
	        })
	    ], ControlsModelViewerElement.prototype, "interpolationDecay", void 0);
	    __decorate$6([
	        n$2()
	    ], ControlsModelViewerElement.prototype, "a11y", void 0);
	    return ControlsModelViewerElement;
	};

	const PAN_SENSITIVITY = 0.018;
	const TAP_DISTANCE = 2;
	const TAP_MS = 300;
	const vector2 = new Vector2();
	const vector3$2 = new Vector3();
	const DEFAULT_OPTIONS = Object.freeze({
	    minimumRadius: 0,
	    maximumRadius: Infinity,
	    minimumPolarAngle: 0,
	    maximumPolarAngle: Math.PI,
	    minimumAzimuthalAngle: -Infinity,
	    maximumAzimuthalAngle: Infinity,
	    minimumFieldOfView: 10,
	    maximumFieldOfView: 45,
	    touchAction: 'none'
	});
	const KEYBOARD_ORBIT_INCREMENT = Math.PI / 8;
	const ZOOM_SENSITIVITY = 0.04;
	const PAN_KEY_INCREMENT = 10;
	const ChangeSource = {
	    USER_INTERACTION: 'user-interaction',
	    NONE: 'none',
	    AUTOMATIC: 'automatic'
	};
	 class SmoothControls extends EventDispatcher {
	    get interactionEnabled() {
	        return this._interactionEnabled;
	    }
	    enableInteraction() {
	        if (this._interactionEnabled === false) {
	            const { element } = this;
	            element.addEventListener('pointerdown', this.onPointerDown);
	            element.addEventListener('pointercancel', this.onPointerUp);
	            if (!this._disableZoom) {
	                element.addEventListener('wheel', this.onWheel);
	            }
	            element.addEventListener('keydown', this.onKeyDown);
	            element.addEventListener('touchmove', ()=>{}, {
	                passive: false
	            });
	            element.addEventListener('contextmenu', this.onContext);
	            this.element.style.cursor = 'grab';
	            this._interactionEnabled = true;
	            this.updateTouchActionStyle();
	        }
	    }
	    disableInteraction() {
	        if (this._interactionEnabled === true) {
	            const { element } = this;
	            element.removeEventListener('pointerdown', this.onPointerDown);
	            element.removeEventListener('pointermove', this.onPointerMove);
	            element.removeEventListener('pointerup', this.onPointerUp);
	            element.removeEventListener('pointercancel', this.onPointerUp);
	            element.removeEventListener('wheel', this.onWheel);
	            element.removeEventListener('keydown', this.onKeyDown);
	            element.removeEventListener('contextmenu', this.onContext);
	            element.style.cursor = '';
	            this.touchMode = null;
	            this._interactionEnabled = false;
	            this.updateTouchActionStyle();
	        }
	    }
	 get options() {
	        return this._options;
	    }
	    set disableZoom(disable) {
	        if (this._disableZoom != disable) {
	            this._disableZoom = disable;
	            if (disable === true) {
	                this.element.removeEventListener('wheel', this.onWheel);
	            } else {
	                this.element.addEventListener('wheel', this.onWheel);
	            }
	            this.updateTouchActionStyle();
	        }
	    }
	 getCameraSpherical(target = new Spherical()) {
	        return target.copy(this.spherical);
	    }
	 getFieldOfView() {
	        return this.camera.fov;
	    }
	 applyOptions(_options) {
	        Object.assign(this._options, _options);
	        this.setOrbit();
	        this.setFieldOfView(Math.exp(this.goalLogFov));
	    }
	 updateNearFar(nearPlane, farPlane) {
	        this.camera.far = farPlane === 0 ? 2 : farPlane;
	        this.camera.near = Math.max(nearPlane, this.camera.far / 1000);
	        this.camera.updateProjectionMatrix();
	    }
	 updateAspect(aspect) {
	        this.camera.aspect = aspect;
	        this.camera.updateProjectionMatrix();
	    }
	 setOrbit(goalTheta = this.goalSpherical.theta, goalPhi = this.goalSpherical.phi, goalRadius = this.goalSpherical.radius) {
	        const { minimumAzimuthalAngle, maximumAzimuthalAngle, minimumPolarAngle, maximumPolarAngle, minimumRadius, maximumRadius } = this._options;
	        const { theta, phi, radius } = this.goalSpherical;
	        const nextTheta = clamp(goalTheta, minimumAzimuthalAngle, maximumAzimuthalAngle);
	        if (!isFinite(minimumAzimuthalAngle) && !isFinite(maximumAzimuthalAngle)) {
	            this.spherical.theta = this.wrapAngle(this.spherical.theta - nextTheta) + nextTheta;
	        }
	        const nextPhi = clamp(goalPhi, minimumPolarAngle, maximumPolarAngle);
	        const nextRadius = clamp(goalRadius, minimumRadius, maximumRadius);
	        if (nextTheta === theta && nextPhi === phi && nextRadius === radius) {
	            return false;
	        }
	        if (!isFinite(nextTheta) || !isFinite(nextPhi) || !isFinite(nextRadius)) {
	            return false;
	        }
	        this.goalSpherical.theta = nextTheta;
	        this.goalSpherical.phi = nextPhi;
	        this.goalSpherical.radius = nextRadius;
	        this.goalSpherical.makeSafe();
	        return true;
	    }
	 setRadius(radius) {
	        this.goalSpherical.radius = radius;
	        this.setOrbit();
	    }
	 setFieldOfView(fov) {
	        const { minimumFieldOfView, maximumFieldOfView } = this._options;
	        fov = clamp(fov, minimumFieldOfView, maximumFieldOfView);
	        this.goalLogFov = Math.log(fov);
	    }
	 setDamperDecayTime(decayMilliseconds) {
	        this.thetaDamper.setDecayTime(decayMilliseconds);
	        this.phiDamper.setDecayTime(decayMilliseconds);
	        this.radiusDamper.setDecayTime(decayMilliseconds);
	        this.fovDamper.setDecayTime(decayMilliseconds);
	    }
	 adjustOrbit(deltaTheta, deltaPhi, deltaZoom) {
	        const { theta, phi, radius } = this.goalSpherical;
	        const { minimumRadius, maximumRadius, minimumFieldOfView, maximumFieldOfView } = this._options;
	        const dTheta = this.spherical.theta - theta;
	        const dThetaLimit = Math.PI - 0.001;
	        const goalTheta = theta - clamp(deltaTheta, -dThetaLimit - dTheta, dThetaLimit - dTheta);
	        const goalPhi = phi - deltaPhi;
	        const deltaRatio = deltaZoom === 0 ? 0 : ((deltaZoom > 0 ? maximumRadius : minimumRadius) - radius) / (Math.log(deltaZoom > 0 ? maximumFieldOfView : minimumFieldOfView) - this.goalLogFov);
	        const goalRadius = radius + deltaZoom * (isFinite(deltaRatio) ? deltaRatio : (maximumRadius - minimumRadius) * 2);
	        this.setOrbit(goalTheta, goalPhi, goalRadius);
	        if (deltaZoom !== 0) {
	            const goalLogFov = this.goalLogFov + deltaZoom;
	            this.setFieldOfView(Math.exp(goalLogFov));
	        }
	    }
	 jumpToGoal() {
	        this.update(0, SETTLING_TIME);
	    }
	 update(_time, delta) {
	        if (this.isStationary()) {
	            return false;
	        }
	        const { maximumPolarAngle, maximumRadius } = this._options;
	        const dTheta = this.spherical.theta - this.goalSpherical.theta;
	        if (Math.abs(dTheta) > Math.PI && !isFinite(this._options.minimumAzimuthalAngle) && !isFinite(this._options.maximumAzimuthalAngle)) {
	            this.spherical.theta -= Math.sign(dTheta) * 2 * Math.PI;
	        }
	        this.spherical.theta = this.thetaDamper.update(this.spherical.theta, this.goalSpherical.theta, delta, Math.PI);
	        this.spherical.phi = this.phiDamper.update(this.spherical.phi, this.goalSpherical.phi, delta, maximumPolarAngle);
	        this.spherical.radius = this.radiusDamper.update(this.spherical.radius, this.goalSpherical.radius, delta, maximumRadius);
	        this.logFov = this.fovDamper.update(this.logFov, this.goalLogFov, delta, 1);
	        this.moveCamera();
	        return true;
	    }
	    updateTouchActionStyle() {
	        const { style } = this.element;
	        if (this._interactionEnabled) {
	            const { touchAction } = this._options;
	            if (this._disableZoom && touchAction !== 'none') {
	                style.touchAction = 'manipulation';
	            } else {
	                style.touchAction = touchAction;
	            }
	        } else {
	            style.touchAction = '';
	        }
	    }
	    isStationary() {
	        return this.goalSpherical.theta === this.spherical.theta && this.goalSpherical.phi === this.spherical.phi && this.goalSpherical.radius === this.spherical.radius && this.goalLogFov === this.logFov;
	    }
	    moveCamera() {
	        this.spherical.makeSafe();
	        this.camera.position.setFromSpherical(this.spherical);
	        this.camera.setRotationFromEuler(new Euler(this.spherical.phi - Math.PI / 2, this.spherical.theta, 0, 'YXZ'));
	        if (this.camera.fov !== Math.exp(this.logFov)) {
	            this.camera.fov = Math.exp(this.logFov);
	            this.camera.updateProjectionMatrix();
	        }
	    }
	    userAdjustOrbit(deltaTheta, deltaPhi, deltaZoom) {
	        this.adjustOrbit(deltaTheta * this.orbitSensitivity * this.inputSensitivity, deltaPhi * this.orbitSensitivity * this.inputSensitivity, deltaZoom * this.inputSensitivity);
	    }
	    wrapAngle(radians) {
	        const normalized = (radians + Math.PI) / (2 * Math.PI);
	        const wrapped = normalized - Math.floor(normalized);
	        return wrapped * 2 * Math.PI - Math.PI;
	    }
	    pixelLengthToSphericalAngle(pixelLength) {
	        return 2 * Math.PI * pixelLength / this.scene.height;
	    }
	    twoTouchDistance(touchOne, touchTwo) {
	        const { clientX: xOne, clientY: yOne } = touchOne;
	        const { clientX: xTwo, clientY: yTwo } = touchTwo;
	        const xDelta = xTwo - xOne;
	        const yDelta = yTwo - yOne;
	        return Math.sqrt(xDelta * xDelta + yDelta * yDelta);
	    }
	    handleSinglePointerMove(dx, dy) {
	        const deltaTheta = this.pixelLengthToSphericalAngle(dx);
	        const deltaPhi = this.pixelLengthToSphericalAngle(dy);
	        if (this.isUserPointing === false) {
	            this.isUserPointing = true;
	            this.dispatchEvent({
	                type: 'pointer-change-start'
	            });
	        }
	        this.userAdjustOrbit(deltaTheta, deltaPhi, 0);
	    }
	    initializePan() {
	        const { theta, phi } = this.spherical;
	        const psi = theta - this.scene.yaw;
	        this.panPerPixel = PAN_SENSITIVITY * this.panSensitivity / this.scene.height;
	        this.panProjection.set(-Math.cos(psi), -Math.cos(phi) * Math.sin(psi), 0, 0, Math.sin(phi), 0, Math.sin(psi), -Math.cos(phi) * Math.cos(psi), 0);
	    }
	    movePan(dx, dy) {
	        const { scene } = this;
	        const dxy = vector3$2.set(dx, dy, 0).multiplyScalar(this.inputSensitivity);
	        const metersPerPixel = this.spherical.radius * Math.exp(this.logFov) * this.panPerPixel;
	        dxy.multiplyScalar(metersPerPixel);
	        const target = scene.getTarget();
	        target.add(dxy.applyMatrix3(this.panProjection));
	        scene.boundingSphere.clampPoint(target, target);
	        scene.setTarget(target.x, target.y, target.z);
	    }
	    recenter(pointer) {
	        if (performance.now() > this.startTime + TAP_MS || Math.abs(pointer.clientX - this.startPointerPosition.clientX) > TAP_DISTANCE || Math.abs(pointer.clientY - this.startPointerPosition.clientY) > TAP_DISTANCE) {
	            return;
	        }
	        const { scene } = this;
	        const hit = scene.positionAndNormalFromPoint(scene.getNDC(pointer.clientX, pointer.clientY));
	        if (hit == null) {
	            const { cameraTarget } = scene.element;
	            scene.element.cameraTarget = '';
	            scene.element.cameraTarget = cameraTarget;
	            this.userAdjustOrbit(0, 0, 1);
	        } else {
	            scene.target.worldToLocal(hit.position);
	            scene.setTarget(hit.position.x, hit.position.y, hit.position.z);
	        }
	    }
	    resetRadius() {
	        const { scene } = this;
	        const hit = scene.positionAndNormalFromPoint(vector2.set(0, 0));
	        if (hit == null) {
	            return;
	        }
	        scene.target.worldToLocal(hit.position);
	        const goalTarget = scene.getTarget();
	        const { theta, phi } = this.spherical;
	        const psi = theta - scene.yaw;
	        const n = vector3$2.set(Math.sin(phi) * Math.sin(psi), Math.cos(phi), Math.sin(phi) * Math.cos(psi));
	        const dr = n.dot(hit.position.sub(goalTarget));
	        goalTarget.add(n.multiplyScalar(dr));
	        scene.setTarget(goalTarget.x, goalTarget.y, goalTarget.z);
	        this.setOrbit(undefined, undefined, this.goalSpherical.radius - dr);
	    }
	    onTouchChange(event) {
	        if (this.pointers.length === 1) {
	            this.touchMode = this.touchModeRotate;
	        } else {
	            if (this._disableZoom) {
	                this.touchMode = null;
	                this.element.removeEventListener('touchmove', this.disableScroll);
	                return;
	            }
	            this.touchMode = this.touchDecided && this.touchMode === null ? null : this.touchModeZoom;
	            this.touchDecided = true;
	            this.element.addEventListener('touchmove', this.disableScroll, {
	                passive: false
	            });
	            this.lastSeparation = this.twoTouchDistance(this.pointers[0], this.pointers[1]);
	            if (this.enablePan && this.touchMode != null) {
	                this.initializePan();
	                if (!event.altKey) {
	                    this.scene.element[$panElement].style.opacity = 1;
	                }
	            }
	        }
	    }
	    onMouseDown(event) {
	        this.panPerPixel = 0;
	        if (this.enablePan && (event.button === 2 || event.ctrlKey || event.metaKey || event.shiftKey)) {
	            this.initializePan();
	            this.scene.element[$panElement].style.opacity = 1;
	        }
	        this.element.style.cursor = 'grabbing';
	    }
	 orbitZoomKeyCodeHandler(event) {
	        let relevantKey = true;
	        switch(event.key){
	            case 'PageUp':
	                this.userAdjustOrbit(0, 0, ZOOM_SENSITIVITY * this.zoomSensitivity);
	                break;
	            case 'PageDown':
	                this.userAdjustOrbit(0, 0, -1 * ZOOM_SENSITIVITY * this.zoomSensitivity);
	                break;
	            case 'ArrowUp':
	                this.userAdjustOrbit(0, -KEYBOARD_ORBIT_INCREMENT, 0);
	                break;
	            case 'ArrowDown':
	                this.userAdjustOrbit(0, KEYBOARD_ORBIT_INCREMENT, 0);
	                break;
	            case 'ArrowLeft':
	                this.userAdjustOrbit(-KEYBOARD_ORBIT_INCREMENT, 0, 0);
	                break;
	            case 'ArrowRight':
	                this.userAdjustOrbit(KEYBOARD_ORBIT_INCREMENT, 0, 0);
	                break;
	            default:
	                relevantKey = false;
	                break;
	        }
	        return relevantKey;
	    }
	 panKeyCodeHandler(event) {
	        this.initializePan();
	        let relevantKey = true;
	        switch(event.key){
	            case 'ArrowUp':
	                this.movePan(0, -1 * PAN_KEY_INCREMENT);
	                break;
	            case 'ArrowDown':
	                this.movePan(0, PAN_KEY_INCREMENT);
	                break;
	            case 'ArrowLeft':
	                this.movePan(-1 * PAN_KEY_INCREMENT, 0);
	                break;
	            case 'ArrowRight':
	                this.movePan(PAN_KEY_INCREMENT, 0);
	                break;
	            default:
	                relevantKey = false;
	                break;
	        }
	        return relevantKey;
	    }
	    constructor(camera, element, scene){
	        super();
	        this.camera = camera;
	        this.element = element;
	        this.scene = scene;
	        this.orbitSensitivity = 1;
	        this.zoomSensitivity = 1;
	        this.panSensitivity = 1;
	        this.inputSensitivity = 1;
	        this.changeSource = ChangeSource.NONE;
	        this._interactionEnabled = false;
	        this._disableZoom = false;
	        this.isUserPointing = false;
	        this.enablePan = true;
	        this.enableTap = true;
	        this.panProjection = new Matrix3();
	        this.panPerPixel = 0;
	        this.spherical = new Spherical();
	        this.goalSpherical = new Spherical();
	        this.thetaDamper = new Damper();
	        this.phiDamper = new Damper();
	        this.radiusDamper = new Damper();
	        this.logFov = Math.log(DEFAULT_OPTIONS.maximumFieldOfView);
	        this.goalLogFov = this.logFov;
	        this.fovDamper = new Damper();
	        this.touchMode = null;
	        this.pointers = [];
	        this.startTime = 0;
	        this.startPointerPosition = {
	            clientX: 0,
	            clientY: 0
	        };
	        this.lastSeparation = 0;
	        this.touchDecided = false;
	        this.onContext = (event)=>{
	            if (this.enablePan) {
	                event.preventDefault();
	            } else {
	                for (const pointer of this.pointers){
	                    this.onPointerUp(new PointerEvent('pointercancel', Object.assign(Object.assign({}, this.startPointerPosition), {
	                        pointerId: pointer.id
	                    })));
	                }
	            }
	        };
	        this.touchModeZoom = (dx, dy)=>{
	            if (!this._disableZoom) {
	                const touchDistance = this.twoTouchDistance(this.pointers[0], this.pointers[1]);
	                const deltaZoom = ZOOM_SENSITIVITY * this.zoomSensitivity * (this.lastSeparation - touchDistance) * 50 / this.scene.height;
	                this.lastSeparation = touchDistance;
	                this.userAdjustOrbit(0, 0, deltaZoom);
	            }
	            if (this.panPerPixel > 0) {
	                this.movePan(dx, dy);
	            }
	        };
	        this.disableScroll = (event)=>{
	            event.preventDefault();
	        };
	        this.touchModeRotate = (dx, dy)=>{
	            const { touchAction } = this._options;
	            if (!this.touchDecided && touchAction !== 'none') {
	                this.touchDecided = true;
	                const dxMag = Math.abs(dx);
	                const dyMag = Math.abs(dy);
	                if (this.changeSource === ChangeSource.USER_INTERACTION && (touchAction === 'pan-y' && dyMag > dxMag || touchAction === 'pan-x' && dxMag > dyMag)) {
	                    this.touchMode = null;
	                    return;
	                } else {
	                    this.element.addEventListener('touchmove', this.disableScroll, {
	                        passive: false
	                    });
	                }
	            }
	            this.handleSinglePointerMove(dx, dy);
	        };
	        this.onPointerDown = (event)=>{
	            if (this.pointers.length > 2) {
	                return;
	            }
	            const { element } = this;
	            if (this.pointers.length === 0) {
	                element.addEventListener('pointermove', this.onPointerMove);
	                element.addEventListener('pointerup', this.onPointerUp);
	                this.touchMode = null;
	                this.touchDecided = false;
	                this.startPointerPosition.clientX = event.clientX;
	                this.startPointerPosition.clientY = event.clientY;
	                this.startTime = performance.now();
	            }
	            try {
	                element.setPointerCapture(event.pointerId);
	            } catch (_a) {}
	            this.pointers.push({
	                clientX: event.clientX,
	                clientY: event.clientY,
	                id: event.pointerId
	            });
	            this.isUserPointing = false;
	            if (event.pointerType === 'touch') {
	                this.changeSource = event.altKey ? ChangeSource.AUTOMATIC : ChangeSource.USER_INTERACTION;
	                this.onTouchChange(event);
	            } else {
	                this.changeSource = ChangeSource.USER_INTERACTION;
	                this.onMouseDown(event);
	            }
	            if (this.changeSource === ChangeSource.USER_INTERACTION) {
	                this.dispatchEvent({
	                    type: 'user-interaction'
	                });
	            }
	        };
	        this.onPointerMove = (event)=>{
	            const pointer = this.pointers.find((pointer)=>pointer.id === event.pointerId);
	            if (pointer == null) {
	                return;
	            }
	            if (event.pointerType === 'mouse' && event.buttons === 0) {
	                this.onPointerUp(event);
	                return;
	            }
	            const numTouches = this.pointers.length;
	            const dx = (event.clientX - pointer.clientX) / numTouches;
	            const dy = (event.clientY - pointer.clientY) / numTouches;
	            if (dx === 0 && dy === 0) {
	                return;
	            }
	            pointer.clientX = event.clientX;
	            pointer.clientY = event.clientY;
	            if (event.pointerType === 'touch') {
	                this.changeSource = event.altKey ? ChangeSource.AUTOMATIC : ChangeSource.USER_INTERACTION;
	                if (this.touchMode !== null) {
	                    this.touchMode(dx, dy);
	                }
	            } else {
	                this.changeSource = ChangeSource.USER_INTERACTION;
	                if (this.panPerPixel > 0) {
	                    this.movePan(dx, dy);
	                } else {
	                    this.handleSinglePointerMove(dx, dy);
	                }
	            }
	        };
	        this.onPointerUp = (event)=>{
	            const { element } = this;
	            const index = this.pointers.findIndex((pointer)=>pointer.id === event.pointerId);
	            if (index !== -1) {
	                this.pointers.splice(index, 1);
	            }
	            if (this.panPerPixel > 0 && !event.altKey) {
	                this.resetRadius();
	            }
	            if (this.pointers.length === 0) {
	                element.removeEventListener('pointermove', this.onPointerMove);
	                element.removeEventListener('pointerup', this.onPointerUp);
	                element.removeEventListener('touchmove', this.disableScroll);
	                if (this.enablePan && this.enableTap) {
	                    this.recenter(event);
	                }
	            } else if (this.touchMode !== null) {
	                this.onTouchChange(event);
	            }
	            this.scene.element[$panElement].style.opacity = 0;
	            element.style.cursor = 'grab';
	            this.panPerPixel = 0;
	            if (this.isUserPointing) {
	                this.dispatchEvent({
	                    type: 'pointer-change-end'
	                });
	            }
	        };
	        this.onWheel = (event)=>{
	            this.changeSource = ChangeSource.USER_INTERACTION;
	            const deltaZoom = event.deltaY * (event.deltaMode == 1 ? 18 : 1) * ZOOM_SENSITIVITY * this.zoomSensitivity / 30;
	            this.userAdjustOrbit(0, 0, deltaZoom);
	            event.preventDefault();
	            this.dispatchEvent({
	                type: 'user-interaction'
	            });
	        };
	        this.onKeyDown = (event)=>{
	            const { changeSource } = this;
	            this.changeSource = ChangeSource.USER_INTERACTION;
	            const relevantKey = event.shiftKey && this.enablePan ? this.panKeyCodeHandler(event) : this.orbitZoomKeyCodeHandler(event);
	            if (relevantKey) {
	                event.preventDefault();
	                this.dispatchEvent({
	                    type: 'user-interaction'
	                });
	            } else {
	                this.changeSource = changeSource;
	            }
	        };
	        this._options = Object.assign({}, DEFAULT_OPTIONS);
	        this.setOrbit(0, Math.PI / 2, 1);
	        this.setFieldOfView(100);
	        this.jumpToGoal();
	    }
	}

	const INIT_FRAMES = 30;
	const AR_SHADOW_INTENSITY = 0.8;
	const ROTATION_RATE = 1.5;
	const HIT_ANGLE_DEG = 20;
	const SCALE_SNAP = 0.2;
	const MIN_VIEWPORT_SCALE = 0.25;
	const MAX_DISTANCE = 10;
	const DECAY = 150;
	const MAX_LINE_LENGTH = 5;
	const BOX_SIZE = 0.1;
	const ARStatus = {
	    NOT_PRESENTING: 'not-presenting',
	    SESSION_STARTED: 'session-started',
	    OBJECT_PLACED: 'object-placed',
	    FAILED: 'failed'
	};
	const ARTracking = {
	    TRACKING: 'tracking',
	    NOT_TRACKING: 'not-tracking'
	};
	const vector3$1 = new Vector3();
	const quaternion = new Quaternion();
	const matrix4 = new Matrix4();
	const hitPosition = new Vector3();
	const camera = new PerspectiveCamera(45, 1, 0.1, 100);
	const lineGeometry = new BufferGeometry().setFromPoints([
	    new Vector3(0, 0, 0),
	    new Vector3(0, 0, -1)
	]);
	const boxGeometry = new BoxGeometry();
	class ARRenderer extends EventDispatcher {
	    async resolveARSession() {
	        assertIsArCandidate();
	        const session = await navigator.xr.requestSession('immersive-ar', {
	            requiredFeatures: [],
	            optionalFeatures: [
	                'hit-test',
	                'dom-overlay',
	                'light-estimation'
	            ],
	            domOverlay: this.overlay ? {
	                root: this.overlay
	            } : undefined
	        });
	        this.threeRenderer.xr.setReferenceSpaceType('local');
	        await this.threeRenderer.xr.setSession(session);
	        this.threeRenderer.xr.cameraAutoUpdate = false;
	        return session;
	    }
	 get presentedScene() {
	        return this._presentedScene;
	    }
	 async supportsPresentation() {
	        try {
	            assertIsArCandidate();
	            return await navigator.xr.isSessionSupported('immersive-ar');
	        } catch (error) {
	            console.warn('Request to present in WebXR denied:');
	            console.warn(error);
	            console.warn('Falling back to next ar-mode');
	            return false;
	        }
	    }
	 async present(scene, environmentEstimation = false) {
	        if (this.isPresenting) {
	            console.warn('Cannot present while a model is already presenting');
	        }
	        let waitForAnimationFrame = new Promise((resolve, _reject)=>{
	            requestAnimationFrame(()=>resolve());
	        });
	        scene.setHotspotsVisibility(false);
	        scene.queueRender();
	        await waitForAnimationFrame;
	        this._presentedScene = scene;
	        this.overlay = scene.element.shadowRoot.querySelector('div.default');
	        if (environmentEstimation === true) {
	            this.xrLight = new XREstimatedLight(this.threeRenderer);
	            this.xrLight.addEventListener('estimationstart', ()=>{
	                if (!this.isPresenting || this.xrLight == null) {
	                    return;
	                }
	                const scene = this.presentedScene;
	                scene.add(this.xrLight);
	                scene.environment = this.xrLight.environment;
	            });
	        }
	        const currentSession = await this.resolveARSession();
	        currentSession.addEventListener('end', ()=>{
	            this.postSessionCleanup();
	        }, {
	            once: true
	        });
	        const exitButton = scene.element.shadowRoot.querySelector('.slot.exit-webxr-ar-button');
	        exitButton.classList.add('enabled');
	        exitButton.addEventListener('click', this.onExitWebXRButtonContainerClick);
	        this.exitWebXRButtonContainer = exitButton;
	        const viewerRefSpace = await currentSession.requestReferenceSpace('viewer');
	        this.xrMode = currentSession.interactionMode;
	        this.tracking = true;
	        this.frames = 0;
	        this.initialized = false;
	        this.turntableRotation = scene.yaw;
	        this.goalYaw = scene.yaw;
	        this.goalScale = 1;
	        scene.setBackground(null);
	        this.oldShadowIntensity = scene.shadowIntensity;
	        scene.setShadowIntensity(0.01);
	        this.oldTarget.copy(scene.getTarget());
	        scene.element.addEventListener('load', this.onUpdateScene);
	        const radians = HIT_ANGLE_DEG * Math.PI / 180;
	        const ray = this.placeOnWall === true ? undefined : new XRRay(new DOMPoint(0, 0, 0), {
	            x: 0,
	            y: -Math.sin(radians),
	            z: -Math.cos(radians)
	        });
	        currentSession.requestHitTestSource({
	            space: viewerRefSpace,
	            offsetRay: ray
	        }).then((hitTestSource)=>{
	            this.initialHitSource = hitTestSource;
	        });
	        if (this.xrMode !== 'screen-space') {
	            this.setupControllers();
	            this.xDamper.setDecayTime(DECAY);
	            this.yDamper.setDecayTime(DECAY);
	            this.zDamper.setDecayTime(DECAY);
	            this.yawDamper.setDecayTime(DECAY);
	            this.pitchDamper.setDecayTime(DECAY);
	            this.rollDamper.setDecayTime(DECAY);
	        }
	        this.currentSession = currentSession;
	        this.placementBox = new PlacementBox(scene, this.placeOnWall ? 'back' : 'bottom');
	        this.placementComplete = false;
	        this.lastTick = performance.now();
	        this.dispatchEvent({
	            type: 'status',
	            status: ARStatus.SESSION_STARTED
	        });
	    }
	    setupControllers() {
	        this.controller1 = this.threeRenderer.xr.getController(0);
	        this.controller1.addEventListener('selectstart', this.onControllerSelectStart);
	        this.controller1.addEventListener('selectend', this.onControllerSelectEnd);
	        this.controller2 = this.threeRenderer.xr.getController(1);
	        this.controller2.addEventListener('selectstart', this.onControllerSelectStart);
	        this.controller2.addEventListener('selectend', this.onControllerSelectEnd);
	        const scene = this.presentedScene;
	        scene.add(this.controller1);
	        scene.add(this.controller2);
	        if (!this.controller1.userData.line) {
	            const line = new Line(lineGeometry);
	            line.name = 'line';
	            line.scale.z = MAX_LINE_LENGTH;
	            this.controller1.userData.turning = false;
	            this.controller1.userData.line = line;
	            this.controller1.add(line);
	            this.controller2.userData.turning = false;
	            const line2 = line.clone();
	            this.controller2.userData.line = line2;
	            this.controller2.add(line2);
	            this.scaleLine.name = 'scale line';
	            this.scaleLine.visible = false;
	            this.controller1.add(this.scaleLine);
	            const { size } = scene;
	            const scale = BOX_SIZE / Math.max(size.x, size.y, size.z);
	            const box = new Mesh(boxGeometry);
	            box.name = 'box';
	            box.scale.copy(size).multiplyScalar(scale);
	            box.visible = false;
	            this.controller1.userData.box = box;
	            scene.add(box);
	            const box2 = box.clone();
	            this.controller2.userData.box = box2;
	            scene.add(box2);
	        }
	    }
	    hover(controller) {
	        if (this.xrMode === 'screen-space' || this.selectedController == controller) {
	            return false;
	        }
	        const scene = this.presentedScene;
	        const intersection = this.placementBox.controllerIntersection(scene, controller);
	        controller.userData.box.visible = (intersection == null || controller.userData.turning) && !this.isTwoFingering;
	        controller.userData.line.scale.z = intersection == null ? MAX_LINE_LENGTH : intersection.distance;
	        return intersection != null;
	    }
	    controllerSeparation() {
	        return this.controller1.position.distanceTo(this.controller2.position);
	    }
	 async stopPresenting() {
	        if (!this.isPresenting) {
	            return;
	        }
	        const cleanupPromise = new Promise((resolve)=>{
	            this.resolveCleanup = resolve;
	        });
	        try {
	            await this.currentSession.end();
	            await cleanupPromise;
	        } catch (error) {
	            console.warn('Error while trying to end WebXR AR session');
	            console.warn(error);
	            this.postSessionCleanup();
	        }
	    }
	 get isPresenting() {
	        return this.presentedScene != null;
	    }
	    get target() {
	        return this.oldTarget;
	    }
	    updateTarget() {
	        const scene = this.presentedScene;
	        if (scene != null) {
	            const target = scene.getTarget();
	            this.oldTarget.copy(target);
	            if (this.placeOnWall) {
	                target.z = scene.boundingBox.min.z;
	            } else {
	                target.y = scene.boundingBox.min.y;
	            }
	            scene.setTarget(target.x, target.y, target.z);
	        }
	    }
	    postSessionCleanup() {
	        const session = this.currentSession;
	        if (session != null) {
	            session.removeEventListener('selectstart', this.onSelectStart);
	            session.removeEventListener('selectend', this.onSelectEnd);
	            this.currentSession = null;
	        }
	        const scene = this.presentedScene;
	        this._presentedScene = null;
	        if (scene != null) {
	            const { element } = scene;
	            if (this.xrLight != null) {
	                scene.remove(this.xrLight);
	                this.xrLight.dispose();
	                this.xrLight = null;
	            }
	            scene.add(scene.pivot);
	            scene.pivot.quaternion.set(0, 0, 0, 1);
	            scene.pivot.position.set(0, 0, 0);
	            scene.pivot.scale.set(1, 1, 1);
	            scene.setShadowOffset(0);
	            const yaw = this.turntableRotation;
	            if (yaw != null) {
	                scene.yaw = yaw;
	            }
	            const intensity = this.oldShadowIntensity;
	            if (intensity != null) {
	                scene.setShadowIntensity(intensity);
	            }
	            scene.setEnvironmentAndSkybox(element[$currentEnvironmentMap], element[$currentBackground]);
	            const point = this.oldTarget;
	            scene.setTarget(point.x, point.y, point.z);
	            scene.xrCamera = null;
	            scene.element.removeEventListener('load', this.onUpdateScene);
	            scene.orientHotspots(0);
	            const { width, height } = element.getBoundingClientRect();
	            scene.setSize(width, height);
	            requestAnimationFrame(()=>{
	                scene.element.dispatchEvent(new CustomEvent('camera-change', {
	                    detail: {
	                        source: ChangeSource.NONE
	                    }
	                }));
	            });
	        }
	        this.renderer.height = 0;
	        const exitButton = this.exitWebXRButtonContainer;
	        if (exitButton != null) {
	            exitButton.classList.remove('enabled');
	            exitButton.removeEventListener('click', this.onExitWebXRButtonContainerClick);
	            this.exitWebXRButtonContainer = null;
	        }
	        const hitSource = this.transientHitTestSource;
	        if (hitSource != null) {
	            hitSource.cancel();
	            this.transientHitTestSource = null;
	        }
	        const hitSourceInitial = this.initialHitSource;
	        if (hitSourceInitial != null) {
	            hitSourceInitial.cancel();
	            this.initialHitSource = null;
	        }
	        if (this.placementBox != null) {
	            this.placementBox.dispose();
	            this.placementBox = null;
	        }
	        if (this.xrMode !== 'screen-space') {
	            if (this.controller1 != null) {
	                this.controller1.userData.turning = false;
	                this.controller1.userData.box.visible = false;
	                this.controller1.userData.line.visible = true;
	                this.controller1.removeEventListener('selectstart', this.onControllerSelectStart);
	                this.controller1.removeEventListener('selectend', this.onControllerSelectEnd);
	                this.controller1.removeFromParent();
	                this.controller1 = null;
	            }
	            if (this.controller2 != null) {
	                this.controller2.userData.turning = false;
	                this.controller2.userData.box.visible = false;
	                this.controller2.userData.line.visible = true;
	                this.controller2.removeEventListener('selectstart', this.onControllerSelectStart);
	                this.controller2.removeEventListener('selectend', this.onControllerSelectEnd);
	                this.controller2.removeFromParent();
	                this.controller2 = null;
	            }
	            this.selectedController = null;
	            this.scaleLine.visible = false;
	        }
	        this.isTranslating = false;
	        this.isRotating = false;
	        this.isTwoFingering = false;
	        this.lastTick = null;
	        this.turntableRotation = null;
	        this.oldShadowIntensity = null;
	        this.frame = null;
	        this.inputSource = null;
	        this.overlay = null;
	        if (this.resolveCleanup != null) {
	            this.resolveCleanup();
	        }
	        this.dispatchEvent({
	            type: 'status',
	            status: ARStatus.NOT_PRESENTING
	        });
	    }
	    updateView(view) {
	        const scene = this.presentedScene;
	        const xr = this.threeRenderer.xr;
	        xr.updateCamera(camera);
	        scene.xrCamera = xr.getCamera();
	        const { elements } = scene.getCamera().matrixWorld;
	        scene.orientHotspots(Math.atan2(elements[1], elements[5]));
	        if (!this.initialized) {
	            this.placeInitially();
	            this.initialized = true;
	        }
	        if (view.requestViewportScale && view.recommendedViewportScale) {
	            const scale = view.recommendedViewportScale;
	            view.requestViewportScale(Math.max(scale, MIN_VIEWPORT_SCALE));
	        }
	        const layer = xr.getBaseLayer();
	        if (layer != null) {
	            const viewport = layer instanceof XRWebGLLayer ? layer.getViewport(view) : xr.getBinding().getViewSubImage(layer, view).viewport;
	            this.threeRenderer.setViewport(viewport.x, viewport.y, viewport.width, viewport.height);
	        }
	    }
	    placeInitially() {
	        const scene = this.presentedScene;
	        const { pivot, element } = scene;
	        const { position } = pivot;
	        const xrCamera = scene.getCamera();
	        const { width, height } = this.overlay.getBoundingClientRect();
	        scene.setSize(width, height);
	        xrCamera.projectionMatrixInverse.copy(xrCamera.projectionMatrix).invert();
	        const { theta } = element.getCameraOrbit();
	        const cameraDirection = xrCamera.getWorldDirection(vector3$1);
	        scene.yaw = Math.atan2(-cameraDirection.x, -cameraDirection.z) - theta;
	        this.goalYaw = scene.yaw;
	        const radius = Math.max(1, 2 * scene.boundingSphere.radius);
	        position.copy(xrCamera.position).add(cameraDirection.multiplyScalar(radius));
	        this.updateTarget();
	        const target = scene.getTarget();
	        position.add(target).sub(this.oldTarget);
	        this.goalPosition.copy(position);
	        scene.setHotspotsVisibility(true);
	        if (this.xrMode === 'screen-space') {
	            const { session } = this.frame;
	            session.addEventListener('selectstart', this.onSelectStart);
	            session.addEventListener('selectend', this.onSelectEnd);
	            session.requestHitTestSourceForTransientInput({
	                profile: 'generic-touchscreen'
	            }).then((hitTestSource)=>{
	                this.transientHitTestSource = hitTestSource;
	            });
	        }
	    }
	    getTouchLocation() {
	        const { axes } = this.inputSource.gamepad;
	        let location = this.placementBox.getExpandedHit(this.presentedScene, axes[0], axes[1]);
	        if (location != null) {
	            vector3$1.copy(location).sub(this.presentedScene.getCamera().position);
	            if (vector3$1.length() > MAX_DISTANCE) return null;
	        }
	        return location;
	    }
	    getHitPoint(hitResult) {
	        const refSpace = this.threeRenderer.xr.getReferenceSpace();
	        const pose = hitResult.getPose(refSpace);
	        if (pose == null) {
	            return null;
	        }
	        const hitMatrix = matrix4.fromArray(pose.transform.matrix);
	        if (this.placeOnWall === true) {
	            this.goalYaw = Math.atan2(hitMatrix.elements[4], hitMatrix.elements[6]);
	        }
	        return hitMatrix.elements[5] > 0.75 !== this.placeOnWall ? hitPosition.setFromMatrixPosition(hitMatrix) : null;
	    }
	    moveToFloor(frame) {
	        const hitSource = this.initialHitSource;
	        if (hitSource == null) {
	            return;
	        }
	        const hitTestResults = frame.getHitTestResults(hitSource);
	        if (hitTestResults.length == 0) {
	            return;
	        }
	        const hit = hitTestResults[0];
	        const hitPoint = this.getHitPoint(hit);
	        if (hitPoint == null) {
	            return;
	        }
	        this.placementBox.show = true;
	        if (!this.isTranslating) {
	            if (this.placeOnWall) {
	                this.goalPosition.copy(hitPoint);
	            } else {
	                this.goalPosition.y = hitPoint.y;
	            }
	        }
	        hitSource.cancel();
	        this.initialHitSource = null;
	        this.dispatchEvent({
	            type: 'status',
	            status: ARStatus.OBJECT_PLACED
	        });
	    }
	    fingerPolar(fingers) {
	        const fingerOne = fingers[0].inputSource.gamepad.axes;
	        const fingerTwo = fingers[1].inputSource.gamepad.axes;
	        const deltaX = fingerTwo[0] - fingerOne[0];
	        const deltaY = fingerTwo[1] - fingerOne[1];
	        const angle = Math.atan2(deltaY, deltaX);
	        let deltaYaw = this.lastAngle - angle;
	        if (deltaYaw > Math.PI) {
	            deltaYaw -= 2 * Math.PI;
	        } else if (deltaYaw < -Math.PI) {
	            deltaYaw += 2 * Math.PI;
	        }
	        this.lastAngle = angle;
	        return {
	            separation: Math.sqrt(deltaX * deltaX + deltaY * deltaY),
	            deltaYaw: deltaYaw
	        };
	    }
	    setScale(separation) {
	        const scale = separation / this.firstRatio;
	        this.goalScale = Math.abs(scale - 1) < SCALE_SNAP ? 1 : scale;
	    }
	    processInput(frame) {
	        const hitSource = this.transientHitTestSource;
	        if (hitSource == null) {
	            return;
	        }
	        if (!this.isTranslating && !this.isTwoFingering && !this.isRotating) {
	            return;
	        }
	        const fingers = frame.getHitTestResultsForTransientInput(hitSource);
	        const scene = this.presentedScene;
	        const scale = scene.pivot.scale.x;
	        if (this.isTwoFingering) {
	            if (fingers.length < 2) {
	                this.isTwoFingering = false;
	            } else {
	                const { separation, deltaYaw } = this.fingerPolar(fingers);
	                if (this.placeOnWall === false) {
	                    this.goalYaw += deltaYaw;
	                }
	                if (scene.canScale) {
	                    this.setScale(separation);
	                }
	            }
	            return;
	        } else if (fingers.length === 2) {
	            this.isTranslating = false;
	            this.isRotating = false;
	            this.isTwoFingering = true;
	            const { separation } = this.fingerPolar(fingers);
	            this.firstRatio = separation / scale;
	            return;
	        }
	        if (this.isRotating) {
	            const angle = this.inputSource.gamepad.axes[0] * ROTATION_RATE;
	            this.goalYaw += angle - this.lastAngle;
	            this.lastAngle = angle;
	        } else if (this.isTranslating) {
	            fingers.forEach((finger)=>{
	                if (finger.inputSource !== this.inputSource) {
	                    return;
	                }
	                let hit = null;
	                if (finger.results.length > 0) {
	                    hit = this.getHitPoint(finger.results[0]);
	                }
	                if (hit == null) {
	                    hit = this.getTouchLocation();
	                }
	                if (hit == null) {
	                    return;
	                }
	                this.goalPosition.sub(this.lastDragPosition);
	                if (this.placeOnWall === false) {
	                    const offset = hit.y - this.lastDragPosition.y;
	                    if (offset < 0) {
	                        this.placementBox.offsetHeight = offset / scale;
	                        this.presentedScene.setShadowOffset(offset);
	                        const cameraPosition = vector3$1.copy(scene.getCamera().position);
	                        const alpha = -offset / (cameraPosition.y - hit.y);
	                        cameraPosition.multiplyScalar(alpha);
	                        hit.multiplyScalar(1 - alpha).add(cameraPosition);
	                    }
	                }
	                this.goalPosition.add(hit);
	                this.lastDragPosition.copy(hit);
	            });
	        }
	    }
	    moveScene(delta) {
	        const scene = this.presentedScene;
	        const { pivot } = scene;
	        const box = this.placementBox;
	        box.updateOpacity(delta);
	        if (this.controller1) {
	            if (this.controller1.userData.turning) {
	                pivot.quaternion.copy(this.controller1.quaternion).multiply(this.relativeOrientation);
	                if (this.selectedController && this.selectedController === this.controller2) {
	                    pivot.quaternion.premultiply(quaternion.copy(this.controller2.quaternion).invert());
	                }
	            }
	            this.controller1.userData.box.position.copy(this.controller1.position);
	            pivot.getWorldQuaternion(this.controller1.userData.box.quaternion);
	        }
	        if (this.controller2) {
	            if (this.controller2.userData.turning) {
	                pivot.quaternion.copy(this.controller2.quaternion).multiply(this.relativeOrientation);
	                if (this.selectedController && this.selectedController === this.controller1) {
	                    pivot.quaternion.premultiply(quaternion.copy(this.controller1.quaternion).invert());
	                }
	            }
	            this.controller2.userData.box.position.copy(this.controller2.position);
	            pivot.getWorldQuaternion(this.controller2.userData.box.quaternion);
	        }
	        if (this.controller1 && this.controller2 && this.isTwoFingering) {
	            const dist = this.controllerSeparation();
	            this.setScale(dist);
	            this.scaleLine.scale.z = -dist;
	            this.scaleLine.lookAt(this.controller2.position);
	        }
	        const oldScale = scene.pivot.scale.x;
	        if (this.goalScale !== oldScale) {
	            const newScale = this.scaleDamper.update(oldScale, this.goalScale, delta, 1);
	            scene.pivot.scale.set(newScale, newScale, newScale);
	        }
	        if (pivot.parent !== scene) {
	            return;
	        }
	        const { position } = pivot;
	        const boundingRadius = scene.boundingSphere.radius;
	        const goal = this.goalPosition;
	        let source = ChangeSource.NONE;
	        if (!goal.equals(position)) {
	            source = ChangeSource.USER_INTERACTION;
	            let { x, y, z } = position;
	            x = this.xDamper.update(x, goal.x, delta, boundingRadius);
	            y = this.yDamper.update(y, goal.y, delta, boundingRadius);
	            z = this.zDamper.update(z, goal.z, delta, boundingRadius);
	            position.set(x, y, z);
	            if (this.xrMode === 'screen-space' && !this.isTranslating) {
	                const offset = goal.y - y;
	                if (this.placementComplete && this.placeOnWall === false) {
	                    box.offsetHeight = offset / scene.pivot.scale.x;
	                    scene.setShadowOffset(offset);
	                } else if (offset === 0) {
	                    this.placementComplete = true;
	                    box.show = false;
	                    scene.setShadowIntensity(AR_SHADOW_INTENSITY);
	                }
	            }
	            if (this.xrMode !== 'screen-space' && goal.equals(position)) {
	                scene.setShadowIntensity(AR_SHADOW_INTENSITY);
	            }
	        }
	        scene.updateTarget(delta);
	        quaternion.setFromAxisAngle(vector3$1.set(0, 1, 0), this.goalYaw);
	        const angle = scene.pivot.quaternion.angleTo(quaternion);
	        const angleStep = angle - this.yawDamper.update(angle, 0, delta, Math.PI);
	        scene.pivot.quaternion.rotateTowards(quaternion, angleStep);
	        scene.element.dispatchEvent(new CustomEvent('camera-change', {
	            detail: {
	                source
	            }
	        }));
	    }
	 onWebXRFrame(time, frame) {
	        if (this.xrMode !== 'screen-space') {
	            const over1 = this.hover(this.controller1);
	            const over2 = this.hover(this.controller2);
	            this.placementBox.show = (over1 || over2) && !this.isTwoFingering;
	        }
	        this.frame = frame;
	        ++this.frames;
	        const refSpace = this.threeRenderer.xr.getReferenceSpace();
	        const pose = frame.getViewerPose(refSpace);
	        if (pose == null && this.tracking === true && this.frames > INIT_FRAMES) {
	            this.tracking = false;
	            this.dispatchEvent({
	                type: 'tracking',
	                status: ARTracking.NOT_TRACKING
	            });
	        }
	        const scene = this.presentedScene;
	        if (pose == null || scene == null || !scene.element.loaded) {
	            this.threeRenderer.clear();
	            return;
	        }
	        if (this.tracking === false) {
	            this.tracking = true;
	            this.dispatchEvent({
	                type: 'tracking',
	                status: ARTracking.TRACKING
	            });
	        }
	        let isFirstView = true;
	        for (const view of pose.views){
	            this.updateView(view);
	            if (isFirstView) {
	                this.moveToFloor(frame);
	                this.processInput(frame);
	                const delta = time - this.lastTick;
	                this.moveScene(delta);
	                this.renderer.preRender(scene, time, delta);
	                this.lastTick = time;
	                scene.renderShadow(this.threeRenderer);
	            }
	            this.threeRenderer.render(scene, scene.getCamera());
	            isFirstView = false;
	        }
	    }
	    constructor(renderer){
	        super();
	        this.renderer = renderer;
	        this.currentSession = null;
	        this.placeOnWall = false;
	        this.placementBox = null;
	        this.lastTick = null;
	        this.turntableRotation = null;
	        this.oldShadowIntensity = null;
	        this.frame = null;
	        this.initialHitSource = null;
	        this.transientHitTestSource = null;
	        this.inputSource = null;
	        this._presentedScene = null;
	        this.resolveCleanup = null;
	        this.exitWebXRButtonContainer = null;
	        this.overlay = null;
	        this.xrLight = null;
	        this.xrMode = null;
	        this.controller1 = null;
	        this.controller2 = null;
	        this.selectedController = null;
	        this.tracking = true;
	        this.frames = 0;
	        this.initialized = false;
	        this.oldTarget = new Vector3();
	        this.placementComplete = false;
	        this.isTranslating = false;
	        this.isRotating = false;
	        this.isTwoFingering = false;
	        this.lastDragPosition = new Vector3();
	        this.relativeOrientation = new Quaternion();
	        this.scaleLine = new Line(lineGeometry);
	        this.firstRatio = 0;
	        this.lastAngle = 0;
	        this.goalPosition = new Vector3();
	        this.goalYaw = 0;
	        this.goalScale = 1;
	        this.xDamper = new Damper();
	        this.yDamper = new Damper();
	        this.zDamper = new Damper();
	        this.yawDamper = new Damper();
	        this.pitchDamper = new Damper();
	        this.rollDamper = new Damper();
	        this.scaleDamper = new Damper();
	        this.onExitWebXRButtonContainerClick = ()=>this.stopPresenting();
	        this.onControllerSelectStart = (event)=>{
	            const scene = this.presentedScene;
	            const controller = event.target;
	            if (this.placementBox.controllerIntersection(scene, controller) != null) {
	                if (this.selectedController != null) {
	                    this.selectedController.userData.line.visible = false;
	                    if (scene.canScale) {
	                        this.isTwoFingering = true;
	                        this.firstRatio = this.controllerSeparation() / scene.pivot.scale.x;
	                        this.scaleLine.visible = true;
	                    }
	                }
	                controller.attach(scene.pivot);
	                this.selectedController = controller;
	                scene.setShadowIntensity(0.01);
	            } else {
	                const otherController = controller === this.controller1 ? this.controller2 : this.controller1;
	                this.relativeOrientation.copy(controller.quaternion).invert().multiply(scene.pivot.getWorldQuaternion(quaternion));
	                otherController.userData.turning = false;
	                controller.userData.turning = true;
	                controller.userData.line.visible = false;
	            }
	        };
	        this.onControllerSelectEnd = (event)=>{
	            const controller = event.target;
	            controller.userData.turning = false;
	            controller.userData.line.visible = true;
	            this.isTwoFingering = false;
	            this.scaleLine.visible = false;
	            if (this.selectedController != null && this.selectedController != controller) {
	                return;
	            }
	            const scene = this.presentedScene;
	            scene.attach(scene.pivot);
	            this.selectedController = null;
	            this.goalYaw = Math.atan2(scene.pivot.matrix.elements[8], scene.pivot.matrix.elements[10]);
	            this.goalPosition.x = scene.pivot.position.x;
	            this.goalPosition.z = scene.pivot.position.z;
	        };
	        this.onUpdateScene = ()=>{
	            if (this.placementBox != null && this.isPresenting) {
	                this.placementBox.dispose();
	                this.placementBox = new PlacementBox(this.presentedScene, this.placeOnWall ? 'back' : 'bottom');
	            }
	        };
	        this.onSelectStart = (event)=>{
	            const hitSource = this.transientHitTestSource;
	            if (hitSource == null) {
	                return;
	            }
	            const fingers = this.frame.getHitTestResultsForTransientInput(hitSource);
	            const scene = this.presentedScene;
	            const box = this.placementBox;
	            if (fingers.length === 1) {
	                this.inputSource = event.inputSource;
	                const { axes } = this.inputSource.gamepad;
	                const hitPosition = box.getHit(this.presentedScene, axes[0], axes[1]);
	                box.show = true;
	                if (hitPosition != null) {
	                    this.isTranslating = true;
	                    this.lastDragPosition.copy(hitPosition);
	                } else if (this.placeOnWall === false) {
	                    this.isRotating = true;
	                    this.lastAngle = axes[0] * ROTATION_RATE;
	                }
	            } else if (fingers.length === 2) {
	                box.show = true;
	                this.isTwoFingering = true;
	                const { separation } = this.fingerPolar(fingers);
	                this.firstRatio = separation / scene.pivot.scale.x;
	            }
	        };
	        this.onSelectEnd = ()=>{
	            this.isTranslating = false;
	            this.isRotating = false;
	            this.isTwoFingering = false;
	            this.inputSource = null;
	            this.goalPosition.y += this.placementBox.offsetHeight * this.presentedScene.scale.x;
	            this.placementBox.show = false;
	        };
	        this.threeRenderer = renderer.threeRenderer;
	        this.threeRenderer.xr.enabled = true;
	    }
	}

	function clone(source) {
	    const sourceLookup = new Map();
	    const cloneLookup = new Map();
	    const clone = source.clone();
	    parallelTraverse(source, clone, function(sourceNode, clonedNode) {
	        sourceLookup.set(clonedNode, sourceNode);
	        cloneLookup.set(sourceNode, clonedNode);
	    });
	    clone.traverse(function(node) {
	        if (!node.isSkinnedMesh) return;
	        const clonedMesh = node;
	        const sourceMesh = sourceLookup.get(node);
	        const sourceBones = sourceMesh.skeleton.bones;
	        clonedMesh.skeleton = sourceMesh.skeleton.clone();
	        clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
	        clonedMesh.skeleton.bones = sourceBones.map(function(bone) {
	            return cloneLookup.get(bone);
	        });
	        clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
	    });
	    return clone;
	}
	function parallelTraverse(a, b, callback) {
	    callback(a, b);
	    for(let i = 0; i < a.children.length; i++){
	        parallelTraverse(a.children[i], b.children[i], callback);
	    }
	}

	const $prepared = Symbol('prepared');
	const $prepare = Symbol('prepare');
	const $preparedGLTF = Symbol('preparedGLTF');
	const $clone = Symbol('clone');
	 class GLTFInstance {
	 static prepare(source) {
	        if (source.scene == null) {
	            throw new Error('Model does not have a scene');
	        }
	        if (source[$prepared]) {
	            return source;
	        }
	        const prepared = this[$prepare](source);
	        prepared[$prepared] = true;
	        return prepared;
	    }
	 static [$prepare](source) {
	        const { scene } = source;
	        const scenes = [
	            scene
	        ];
	        return Object.assign(Object.assign({}, source), {
	            scene,
	            scenes
	        });
	    }
	    get parser() {
	        return this[$preparedGLTF].parser;
	    }
	    get animations() {
	        return this[$preparedGLTF].animations;
	    }
	    get scene() {
	        return this[$preparedGLTF].scene;
	    }
	    get scenes() {
	        return this[$preparedGLTF].scenes;
	    }
	    get cameras() {
	        return this[$preparedGLTF].cameras;
	    }
	    get asset() {
	        return this[$preparedGLTF].asset;
	    }
	    get userData() {
	        return this[$preparedGLTF].userData;
	    }
	 clone() {
	        const GLTFInstanceConstructor = this.constructor;
	        const clonedGLTF = this[$clone]();
	        return new GLTFInstanceConstructor(clonedGLTF);
	    }
	 dispose() {
	        this.scenes.forEach((scene)=>{
	            scene.traverse((object)=>{
	                const mesh = object;
	                if (!mesh.material) {
	                    return;
	                }
	                const materials = Array.isArray(mesh.material) ? mesh.material : [
	                    mesh.material
	                ];
	                materials.forEach((material)=>{
	                    for(const propertyName in material){
	                        const texture = material[propertyName];
	                        if (texture instanceof Texture$1) {
	                            const image = texture.source.data;
	                            if (image.close != null) {
	                                image.close();
	                            }
	                            texture.dispose();
	                        }
	                    }
	                    material.dispose();
	                });
	                mesh.geometry.dispose();
	            });
	        });
	    }
	 [$clone]() {
	        const source = this[$preparedGLTF];
	        const scene = clone(this.scene);
	        cloneVariantMaterials(scene, this.scene);
	        const scenes = [
	            scene
	        ];
	        const userData = source.userData ? Object.assign({}, source.userData) : {};
	        return Object.assign(Object.assign({}, source), {
	            scene,
	            scenes,
	            userData
	        });
	    }
	    constructor(preparedGLTF){
	        this[$preparedGLTF] = preparedGLTF;
	    }
	}
	const cloneVariantMaterials = (dst, src)=>{
	    traversePair(dst, src, (dst, src)=>{
	        if (src.userData.variantMaterials !== undefined) {
	            dst.userData.variantMaterials = new Map(src.userData.variantMaterials);
	        }
	        if (src.userData.variantData !== undefined) {
	            dst.userData.variantData = src.userData.variantData;
	        }
	        if (src.userData.originalMaterial !== undefined) {
	            dst.userData.originalMaterial = src.userData.originalMaterial;
	        }
	    });
	};
	const traversePair = (obj1, obj2, callback)=>{
	    callback(obj1, obj2);
	    for(let i = 0; i < obj1.children.length; i++){
	        traversePair(obj1.children[i], obj2.children[i], callback);
	    }
	};

	const $threeGLTF = Symbol('threeGLTF');
	const $gltf = Symbol('gltf');
	const $gltfElementMap = Symbol('gltfElementMap');
	const $threeObjectMap = Symbol('threeObjectMap');
	const $parallelTraverseThreeScene = Symbol('parallelTraverseThreeScene');
	const $correlateOriginalThreeGLTF = Symbol('correlateOriginalThreeGLTF');
	const $correlateCloneThreeGLTF = Symbol('correlateCloneThreeGLTF');
	 class CorrelatedSceneGraph {
	 static from(threeGLTF, upstreamCorrelatedSceneGraph) {
	        if (upstreamCorrelatedSceneGraph != null) {
	            return this[$correlateCloneThreeGLTF](threeGLTF, upstreamCorrelatedSceneGraph);
	        } else {
	            return this[$correlateOriginalThreeGLTF](threeGLTF);
	        }
	    }
	    static [$correlateOriginalThreeGLTF](threeGLTF) {
	        const gltf = threeGLTF.parser.json;
	        const associations = threeGLTF.parser.associations;
	        const gltfElementMap = new Map();
	        const defaultMaterial = {
	            name: 'Default'
	        };
	        const defaultReference = {
	            index: -1
	        };
	        for (const threeMaterial of associations.keys()){
	            if (threeMaterial instanceof Material$1 && associations.get(threeMaterial) == null) {
	                if (defaultReference.index < 0) {
	                    if (gltf.materials == null) {
	                        gltf.materials = [];
	                    }
	                    defaultReference.index = gltf.materials.length;
	                    gltf.materials.push(defaultMaterial);
	                }
	                threeMaterial.name = defaultMaterial.name;
	                associations.set(threeMaterial, {
	                    materials: defaultReference.index
	                });
	            }
	        }
	        for (const [threeObject, gltfMappings] of associations){
	            if (gltfMappings) {
	                threeObject.userData = threeObject.userData || {};
	                threeObject.userData.associations = gltfMappings;
	            }
	            for(const mapping in gltfMappings){
	                if (mapping != null && mapping !== 'primitives') {
	                    const type = mapping;
	                    const elementArray = gltf[type] || [];
	                    const gltfElement = elementArray[gltfMappings[type]];
	                    if (gltfElement == null) {
	                        continue;
	                    }
	                    let threeObjects = gltfElementMap.get(gltfElement);
	                    if (threeObjects == null) {
	                        threeObjects = new Set();
	                        gltfElementMap.set(gltfElement, threeObjects);
	                    }
	                    threeObjects.add(threeObject);
	                }
	            }
	        }
	        return new CorrelatedSceneGraph(threeGLTF, gltf, associations, gltfElementMap);
	    }
	 static [$correlateCloneThreeGLTF](cloneThreeGLTF, upstreamCorrelatedSceneGraph) {
	        const originalThreeGLTF = upstreamCorrelatedSceneGraph.threeGLTF;
	        const originalGLTF = upstreamCorrelatedSceneGraph.gltf;
	        const cloneGLTF = JSON.parse(JSON.stringify(originalGLTF));
	        const cloneThreeObjectMap = new Map();
	        const cloneGLTFElementMap = new Map();
	        for(let i = 0; i < originalThreeGLTF.scenes.length; i++){
	            this[$parallelTraverseThreeScene](originalThreeGLTF.scenes[i], cloneThreeGLTF.scenes[i], (object, cloneObject)=>{
	                const elementReference = upstreamCorrelatedSceneGraph.threeObjectMap.get(object);
	                if (elementReference == null) {
	                    return;
	                }
	                for(const mapping in elementReference){
	                    if (mapping != null && mapping !== 'primitives') {
	                        const type = mapping;
	                        const index = elementReference[type];
	                        const cloneElement = cloneGLTF[type][index];
	                        const mappings = cloneThreeObjectMap.get(cloneObject) || {};
	                        mappings[type] = index;
	                        cloneThreeObjectMap.set(cloneObject, mappings);
	                        const cloneObjects = cloneGLTFElementMap.get(cloneElement) || new Set();
	                        cloneObjects.add(cloneObject);
	                        cloneGLTFElementMap.set(cloneElement, cloneObjects);
	                    }
	                }
	            });
	        }
	        return new CorrelatedSceneGraph(cloneThreeGLTF, cloneGLTF, cloneThreeObjectMap, cloneGLTFElementMap);
	    }
	 static [$parallelTraverseThreeScene](sceneOne, sceneTwo, callback) {
	        const traverse = (a, b)=>{
	            callback(a, b);
	            if (a.isObject3D) {
	                const meshA = a;
	                const meshB = b;
	                if (meshA.material) {
	                    if (Array.isArray(meshA.material)) {
	                        for(let i = 0; i < meshA.material.length; ++i){
	                            callback(meshA.material[i], meshB.material[i]);
	                        }
	                    } else {
	                        callback(meshA.material, meshB.material);
	                    }
	                }
	                for(let i = 0; i < a.children.length; ++i){
	                    traverse(a.children[i], b.children[i]);
	                }
	            }
	        };
	        traverse(sceneOne, sceneTwo);
	    }
	 get threeGLTF() {
	        return this[$threeGLTF];
	    }
	 get gltf() {
	        return this[$gltf];
	    }
	 get gltfElementMap() {
	        return this[$gltfElementMap];
	    }
	 get threeObjectMap() {
	        return this[$threeObjectMap];
	    }
	    constructor(threeGLTF, gltf, threeObjectMap, gltfElementMap){
	        this[$threeGLTF] = threeGLTF;
	        this[$gltf] = gltf;
	        this[$gltfElementMap] = gltfElementMap;
	        this[$threeObjectMap] = threeObjectMap;
	    }
	}

	const $correlatedSceneGraph = Symbol('correlatedSceneGraph');
	 class ModelViewerGLTFInstance extends GLTFInstance {
	 static [$prepare](source) {
	        const prepared = super[$prepare](source);
	        if (prepared[$correlatedSceneGraph] == null) {
	            prepared[$correlatedSceneGraph] = CorrelatedSceneGraph.from(prepared);
	        }
	        const { scene } = prepared;
	        const nullSphere = new Sphere(undefined, Infinity);
	        scene.traverse((node)=>{
	            node.renderOrder = 1000;
	            node.frustumCulled = false;
	            if (!node.name) {
	                node.name = node.uuid;
	            }
	            const mesh = node;
	            if (mesh.material) {
	                const { geometry } = mesh;
	                mesh.castShadow = true;
	                if (mesh.isSkinnedMesh) {
	                    geometry.boundingSphere = nullSphere;
	                    geometry.boundingBox = null;
	                }
	                const material = mesh.material;
	                if (material.isMeshBasicMaterial === true) {
	                    material.toneMapped = false;
	                }
	                material.shadowSide = FrontSide;
	                if (material.aoMap) {
	                    const { gltf, threeObjectMap } = prepared[$correlatedSceneGraph];
	                    const gltfRef = threeObjectMap.get(material);
	                    if (gltf.materials != null && gltfRef != null && gltfRef.materials != null) {
	                        const gltfMaterial = gltf.materials[gltfRef.materials];
	                        if (gltfMaterial.occlusionTexture && gltfMaterial.occlusionTexture.texCoord === 0 && geometry.attributes.uv != null) {
	                            geometry.setAttribute('uv2', geometry.attributes.uv);
	                        }
	                    }
	                }
	            }
	        });
	        return prepared;
	    }
	    get correlatedSceneGraph() {
	        return this[$preparedGLTF][$correlatedSceneGraph];
	    }
	 [$clone]() {
	        const clone = super[$clone]();
	        const sourceUUIDToClonedMaterial = new Map();
	        clone.scene.traverse((node)=>{
	            const mesh = node;
	            if (mesh.material) {
	                const material = mesh.material;
	                if (material != null) {
	                    if (sourceUUIDToClonedMaterial.has(material.uuid)) {
	                        mesh.material = sourceUUIDToClonedMaterial.get(material.uuid);
	                        return;
	                    }
	                    mesh.material = material.clone();
	                    sourceUUIDToClonedMaterial.set(material.uuid, mesh.material);
	                }
	            }
	            const light = node;
	            if (light.target !== undefined) {
	                light.add(light.target);
	            }
	        });
	        clone[$correlatedSceneGraph] = CorrelatedSceneGraph.from(clone, this.correlatedSceneGraph);
	        return clone;
	    }
	}

	const getBufferForType = (type, width, height)=>{
	    let out;
	    switch(type){
	        case UnsignedByteType:
	            out = new Uint8ClampedArray(width * height * 4);
	            break;
	        case HalfFloatType:
	            out = new Uint16Array(width * height * 4);
	            break;
	        case UnsignedIntType:
	            out = new Uint32Array(width * height * 4);
	            break;
	        case ByteType:
	            out = new Int8Array(width * height * 4);
	            break;
	        case ShortType:
	            out = new Int16Array(width * height * 4);
	            break;
	        case IntType:
	            out = new Int32Array(width * height * 4);
	            break;
	        case FloatType:
	            out = new Float32Array(width * height * 4);
	            break;
	        default:
	            throw new Error('Unsupported data type');
	    }
	    return out;
	};
	let _canReadPixelsResult;
	/**
	 * Test if this browser implementation can correctly read pixels from the specified
	 * Render target type.
	 *
	 * Runs only once
	 *
	 * @param type
	 * @param renderer
	 * @param camera
	 * @param renderTargetOptions
	 * @returns
	 */ const canReadPixels = (type, renderer, camera, renderTargetOptions)=>{
	    if (_canReadPixelsResult !== undefined) return _canReadPixelsResult;
	    const testRT = new WebGLRenderTarget(1, 1, renderTargetOptions);
	    renderer.setRenderTarget(testRT);
	    const mesh = new Mesh(new PlaneGeometry(), new MeshBasicMaterial({
	        color: 0xffffff
	    }));
	    renderer.render(mesh, camera);
	    renderer.setRenderTarget(null);
	    const out = getBufferForType(type, testRT.width, testRT.height);
	    renderer.readRenderTargetPixels(testRT, 0, 0, testRT.width, testRT.height, out);
	    testRT.dispose();
	    mesh.geometry.dispose();
	    mesh.material.dispose();
	    _canReadPixelsResult = out[0] !== 0;
	    return _canReadPixelsResult;
	};
	/**
	 * Utility class used for rendering a texture with a material
	 *
	 * @category Core
	 * @group Core
	 */ class QuadRenderer {
	    /**
	     * Instantiates a temporary renderer
	     *
	     * @returns
	     */ static instantiateRenderer() {
	        const renderer = new WebGLRenderer();
	        renderer.setSize(128, 128);
	        // renderer.outputColorSpace = SRGBColorSpace
	        // renderer.toneMapping = LinearToneMapping
	        // renderer.debug.checkShaderErrors = false
	        // this._rendererIsDisposable = true
	        return renderer;
	    }
	    /**
	     * Obtains a Buffer containing the rendered texture.
	     *
	     * @throws Error if the browser cannot read pixels from this RenderTarget type.
	     * @returns a TypedArray containing RGBA values from this renderer
	     */ toArray() {
	        if (!this._supportsReadPixels) throw new Error('Can\'t read pixels in this browser');
	        const out = getBufferForType(this._type, this._width, this._height);
	        this._renderer.readRenderTargetPixels(this._renderTarget, 0, 0, this._width, this._height, out);
	        return out;
	    }
	    /**
	     * Performs a readPixel operation in the renderTarget
	     * and returns a DataTexture containing the read data
	     *
	     * @param options options
	     * @returns
	     */ toDataTexture(options) {
	        const returnValue = new DataTexture(// fixed values
	        this.toArray(), this.width, this.height, RGBAFormat, this._type, // user values
	        (options === null || options === void 0 ? void 0 : options.mapping) || UVMapping, (options === null || options === void 0 ? void 0 : options.wrapS) || ClampToEdgeWrapping, (options === null || options === void 0 ? void 0 : options.wrapT) || ClampToEdgeWrapping, (options === null || options === void 0 ? void 0 : options.magFilter) || LinearFilter, (options === null || options === void 0 ? void 0 : options.minFilter) || LinearFilter, (options === null || options === void 0 ? void 0 : options.anisotropy) || 1, // fixed value
	        LinearSRGBColorSpace);
	        // set this afterwards, we can't set it in constructor
	        returnValue.generateMipmaps = (options === null || options === void 0 ? void 0 : options.generateMipmaps) !== undefined ? options === null || options === void 0 ? void 0 : options.generateMipmaps : false;
	        return returnValue;
	    }
	    /**
	     * If using a disposable renderer, it will dispose it.
	     */ disposeOnDemandRenderer() {
	        this._renderer.setRenderTarget(null);
	        if (this._rendererIsDisposable) {
	            this._renderer.dispose();
	            this._renderer.forceContextLoss();
	        }
	    }
	    /**
	     * Will dispose of **all** assets used by this renderer.
	     *
	     *
	     * @param disposeRenderTarget will dispose of the renderTarget which will not be usable later
	     * set this to true if you passed the `renderTarget.texture` to a `PMREMGenerator`
	     * or are otherwise done with it.
	     *
	     * @example
	     * ```js
	     * const loader = new HDRJPGLoader(renderer)
	     * const result = await loader.loadAsync('gainmap.jpeg')
	     * const mesh = new Mesh(geometry, new MeshBasicMaterial({ map: result.renderTarget.texture }) )
	     * // DO NOT dispose the renderTarget here,
	     * // it is used directly in the material
	     * result.dispose()
	     * ```
	     *
	     * @example
	     * ```js
	     * const loader = new HDRJPGLoader(renderer)
	     * const pmremGenerator = new PMREMGenerator( renderer );
	     * const result = await loader.loadAsync('gainmap.jpeg')
	     * const envMap = pmremGenerator.fromEquirectangular(result.renderTarget.texture)
	     * const mesh = new Mesh(geometry, new MeshStandardMaterial({ envMap }) )
	     * // renderTarget can be disposed here
	     * // because it was used to generate a PMREM texture
	     * result.dispose(true)
	     * ```
	     */ dispose(disposeRenderTarget) {
	        this.disposeOnDemandRenderer();
	        if (disposeRenderTarget) {
	            this.renderTarget.dispose();
	        }
	        // dispose shader material texture uniforms
	        if (this.material instanceof ShaderMaterial) {
	            Object.values(this.material.uniforms).forEach((v)=>{
	                if (v.value instanceof Texture$1) v.value.dispose();
	            });
	        }
	        // dispose other material properties
	        Object.values(this.material).forEach((value)=>{
	            if (value instanceof Texture$1) value.dispose();
	        });
	        this.material.dispose();
	        this._quad.geometry.dispose();
	    }
	    /**
	     * Width of the texture
	     */ get width() {
	        return this._width;
	    }
	    set width(value) {
	        this._width = value;
	        this._renderTarget.setSize(this._width, this._height);
	    }
	    /**
	     * Height of the texture
	     */ get height() {
	        return this._height;
	    }
	    set height(value) {
	        this._height = value;
	        this._renderTarget.setSize(this._width, this._height);
	    }
	    /**
	     * The renderer used
	     */ get renderer() {
	        return this._renderer;
	    }
	    /**
	     * The `WebGLRenderTarget` used.
	     */ get renderTarget() {
	        return this._renderTarget;
	    }
	    set renderTarget(value) {
	        this._renderTarget = value;
	        this._width = value.width;
	        this._height = value.height;
	    // this._type = value.texture.type
	    }
	    /**
	     * The `Material` used.
	     */ get material() {
	        return this._material;
	    }
	    /**
	     *
	     */ get type() {
	        return this._type;
	    }
	    get colorSpace() {
	        return this._colorSpace;
	    }
	    /**
	     * Constructs a new QuadRenderer
	     *
	     * @param options Parameters for this QuadRenderer
	     */ constructor(options){
	        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
	        this._rendererIsDisposable = false;
	        this._supportsReadPixels = true;
	        /**
	         * Renders the input texture using the specified material
	         */ this.render = ()=>{
	            this._renderer.setRenderTarget(this._renderTarget);
	            try {
	                this._renderer.render(this._scene, this._camera);
	            } catch (e) {
	                this._renderer.setRenderTarget(null);
	                throw e;
	            }
	            this._renderer.setRenderTarget(null);
	        };
	        this._width = options.width;
	        this._height = options.height;
	        this._type = options.type;
	        this._colorSpace = options.colorSpace;
	        const rtOptions = {
	            // fixed options
	            format: RGBAFormat,
	            depthBuffer: false,
	            stencilBuffer: false,
	            // user options
	            type: this._type,
	            colorSpace: this._colorSpace,
	            anisotropy: ((_a = options.renderTargetOptions) === null || _a === void 0 ? void 0 : _a.anisotropy) !== undefined ? (_b = options.renderTargetOptions) === null || _b === void 0 ? void 0 : _b.anisotropy : 1,
	            generateMipmaps: ((_c = options.renderTargetOptions) === null || _c === void 0 ? void 0 : _c.generateMipmaps) !== undefined ? (_d = options.renderTargetOptions) === null || _d === void 0 ? void 0 : _d.generateMipmaps : false,
	            magFilter: ((_e = options.renderTargetOptions) === null || _e === void 0 ? void 0 : _e.magFilter) !== undefined ? (_f = options.renderTargetOptions) === null || _f === void 0 ? void 0 : _f.magFilter : LinearFilter,
	            minFilter: ((_g = options.renderTargetOptions) === null || _g === void 0 ? void 0 : _g.minFilter) !== undefined ? (_h = options.renderTargetOptions) === null || _h === void 0 ? void 0 : _h.minFilter : LinearFilter,
	            samples: ((_j = options.renderTargetOptions) === null || _j === void 0 ? void 0 : _j.samples) !== undefined ? (_k = options.renderTargetOptions) === null || _k === void 0 ? void 0 : _k.samples : undefined,
	            wrapS: ((_l = options.renderTargetOptions) === null || _l === void 0 ? void 0 : _l.wrapS) !== undefined ? (_m = options.renderTargetOptions) === null || _m === void 0 ? void 0 : _m.wrapS : ClampToEdgeWrapping,
	            wrapT: ((_o = options.renderTargetOptions) === null || _o === void 0 ? void 0 : _o.wrapT) !== undefined ? (_p = options.renderTargetOptions) === null || _p === void 0 ? void 0 : _p.wrapT : ClampToEdgeWrapping
	        };
	        this._material = options.material;
	        if (options.renderer) {
	            this._renderer = options.renderer;
	        } else {
	            this._renderer = QuadRenderer.instantiateRenderer();
	            this._rendererIsDisposable = true;
	        }
	        this._scene = new Scene();
	        this._camera = new OrthographicCamera();
	        this._camera.position.set(0, 0, 10);
	        this._camera.left = -0.5;
	        this._camera.right = 0.5;
	        this._camera.top = 0.5;
	        this._camera.bottom = -0.5;
	        this._camera.updateProjectionMatrix();
	        if (!canReadPixels(this._type, this._renderer, this._camera, rtOptions)) {
	            let alternativeType;
	            switch(this._type){
	                case HalfFloatType:
	                    alternativeType = this._renderer.extensions.has('EXT_color_buffer_float') ? FloatType : undefined;
	                    break;
	            }
	            if (alternativeType !== undefined) {
	                console.warn(`This browser does not support reading pixels from ${this._type} RenderTargets, switching to ${FloatType}`);
	                this._type = alternativeType;
	            } else {
	                this._supportsReadPixels = false;
	                console.warn('This browser dos not support toArray or toDataTexture, calls to those methods will result in an error thrown');
	            }
	        }
	        this._quad = new Mesh(new PlaneGeometry(), this._material);
	        this._quad.geometry.computeBoundingBox();
	        this._scene.add(this._quad);
	        this._renderTarget = new WebGLRenderTarget(this.width, this.height, rtOptions);
	        this._renderTarget.texture.mapping = ((_q = options.renderTargetOptions) === null || _q === void 0 ? void 0 : _q.mapping) !== undefined ? (_r = options.renderTargetOptions) === null || _r === void 0 ? void 0 : _r.mapping : UVMapping;
	    }
	}

	const vertexShader = /* glsl */ `
varying vec2 vUv;

void main() {
  vUv = uv;
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;
	const fragmentShader = /* glsl */ `
// min half float value
#define HALF_FLOAT_MIN vec3( -65504, -65504, -65504 )
// max half float value
#define HALF_FLOAT_MAX vec3( 65504, 65504, 65504 )

uniform sampler2D sdr;
uniform sampler2D gainMap;
uniform vec3 gamma;
uniform vec3 offsetHdr;
uniform vec3 offsetSdr;
uniform vec3 gainMapMin;
uniform vec3 gainMapMax;
uniform float weightFactor;

varying vec2 vUv;

void main() {
  vec3 rgb = texture2D( sdr, vUv ).rgb;
  vec3 recovery = texture2D( gainMap, vUv ).rgb;
  vec3 logRecovery = pow( recovery, gamma );
  vec3 logBoost = gainMapMin * ( 1.0 - logRecovery ) + gainMapMax * logRecovery;
  vec3 hdrColor = (rgb + offsetSdr) * exp2( logBoost * weightFactor ) - offsetHdr;
  vec3 clampedHdrColor = max( HALF_FLOAT_MIN, min( HALF_FLOAT_MAX, hdrColor ));
  gl_FragColor = vec4( clampedHdrColor , 1.0 );
}
`;
	/**
	 * A Material which is able to decode the Gainmap into a full HDR Representation
	 *
	 * @category Materials
	 * @group Materials
	 */ class GainMapDecoderMaterial extends ShaderMaterial {
	    get sdr() {
	        return this.uniforms.sdr.value;
	    }
	    set sdr(value) {
	        this.uniforms.sdr.value = value;
	    }
	    get gainMap() {
	        return this.uniforms.gainMap.value;
	    }
	    set gainMap(value) {
	        this.uniforms.gainMap.value = value;
	    }
	    /**
	     * @see {@link GainMapMetadata.offsetHdr}
	     */ get offsetHdr() {
	        return this.uniforms.offsetHdr.value.toArray();
	    }
	    set offsetHdr(value) {
	        this.uniforms.offsetHdr.value.fromArray(value);
	    }
	    /**
	     * @see {@link GainMapMetadata.offsetSdr}
	     */ get offsetSdr() {
	        return this.uniforms.offsetSdr.value.toArray();
	    }
	    set offsetSdr(value) {
	        this.uniforms.offsetSdr.value.fromArray(value);
	    }
	    /**
	     * @see {@link GainMapMetadata.gainMapMin}
	     */ get gainMapMin() {
	        return this.uniforms.gainMapMin.value.toArray();
	    }
	    set gainMapMin(value) {
	        this.uniforms.gainMapMin.value.fromArray(value);
	    }
	    /**
	     * @see {@link GainMapMetadata.gainMapMax}
	     */ get gainMapMax() {
	        return this.uniforms.gainMapMax.value.toArray();
	    }
	    set gainMapMax(value) {
	        this.uniforms.gainMapMax.value.fromArray(value);
	    }
	    /**
	     * @see {@link GainMapMetadata.gamma}
	     */ get gamma() {
	        const g = this.uniforms.gamma.value;
	        return [
	            1 / g.x,
	            1 / g.y,
	            1 / g.z
	        ];
	    }
	    set gamma(value) {
	        const g = this.uniforms.gamma.value;
	        g.x = 1.0 / value[0];
	        g.y = 1.0 / value[1];
	        g.z = 1.0 / value[2];
	    }
	    /**
	     * @see {@link GainMapMetadata.hdrCapacityMin}
	     * @remarks Logarithmic space
	     */ get hdrCapacityMin() {
	        return this._hdrCapacityMin;
	    }
	    set hdrCapacityMin(value) {
	        this._hdrCapacityMin = value;
	        this.calculateWeight();
	    }
	    /**
	     * @see {@link GainMapMetadata.hdrCapacityMin}
	     * @remarks Logarithmic space
	     */ get hdrCapacityMax() {
	        return this._hdrCapacityMax;
	    }
	    set hdrCapacityMax(value) {
	        this._hdrCapacityMax = value;
	        this.calculateWeight();
	    }
	    /**
	     * @see {@link GainmapDecodingParameters.maxDisplayBoost}
	     * @remarks Non Logarithmic space
	     */ get maxDisplayBoost() {
	        return this._maxDisplayBoost;
	    }
	    set maxDisplayBoost(value) {
	        this._maxDisplayBoost = Math.max(1, Math.min(65504, value));
	        this.calculateWeight();
	    }
	    calculateWeight() {
	        const val = (Math.log2(this._maxDisplayBoost) - this._hdrCapacityMin) / (this._hdrCapacityMax - this._hdrCapacityMin);
	        this.uniforms.weightFactor.value = Math.max(0, Math.min(1, val));
	    }
	    /**
	     *
	     * @param params
	     */ constructor({ gamma, offsetHdr, offsetSdr, gainMapMin, gainMapMax, maxDisplayBoost, hdrCapacityMin, hdrCapacityMax, sdr, gainMap }){
	        super({
	            name: 'GainMapDecoderMaterial',
	            vertexShader,
	            fragmentShader,
	            uniforms: {
	                sdr: {
	                    value: sdr
	                },
	                gainMap: {
	                    value: gainMap
	                },
	                gamma: {
	                    value: new Vector3(1.0 / gamma[0], 1.0 / gamma[1], 1.0 / gamma[2])
	                },
	                offsetHdr: {
	                    value: new Vector3().fromArray(offsetHdr)
	                },
	                offsetSdr: {
	                    value: new Vector3().fromArray(offsetSdr)
	                },
	                gainMapMin: {
	                    value: new Vector3().fromArray(gainMapMin)
	                },
	                gainMapMax: {
	                    value: new Vector3().fromArray(gainMapMax)
	                },
	                weightFactor: {
	                    value: (Math.log2(maxDisplayBoost) - hdrCapacityMin) / (hdrCapacityMax - hdrCapacityMin)
	                }
	            },
	            blending: NoBlending,
	            depthTest: false,
	            depthWrite: false
	        });
	        this._maxDisplayBoost = maxDisplayBoost;
	        this._hdrCapacityMin = hdrCapacityMin;
	        this._hdrCapacityMax = hdrCapacityMax;
	        this.needsUpdate = true;
	        this.uniformsNeedUpdate = true;
	    }
	}
	class GainMapNotFoundError extends Error {
	}
	class XMPMetadataNotFoundError extends Error {
	}
	const getXMLValue = (xml, tag, defaultValue)=>{
	    // Check for attribute format first: tag="value"
	    const attributeMatch = new RegExp(`${tag}="([^"]*)"`, 'i').exec(xml);
	    if (attributeMatch) return attributeMatch[1];
	    // Check for tag format: <tag>value</tag> or <tag><rdf:li>value</rdf:li>...</tag>
	    const tagMatch = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'i').exec(xml);
	    if (tagMatch) {
	        // Check if it contains rdf:li elements
	        const liValues = tagMatch[1].match(/<rdf:li>([^<]*)<\/rdf:li>/g);
	        if (liValues && liValues.length === 3) {
	            return liValues.map((v)=>v.replace(/<\/?rdf:li>/g, ''));
	        }
	        return tagMatch[1].trim();
	    }
	    if (defaultValue !== undefined) return defaultValue;
	    throw new Error(`Can't find ${tag} in gainmap metadata`);
	};
	const extractXMP = (input)=>{
	    let str;
	    // support node test environment
	    if (typeof TextDecoder !== 'undefined') str = new TextDecoder().decode(input);
	    else str = input.toString();
	    let start = str.indexOf('<x:xmpmeta');
	    while(start !== -1){
	        const end = str.indexOf('x:xmpmeta>', start);
	        const xmpBlock = str.slice(start, end + 10);
	        try {
	            const gainMapMin = getXMLValue(xmpBlock, 'hdrgm:GainMapMin', '0');
	            const gainMapMax = getXMLValue(xmpBlock, 'hdrgm:GainMapMax');
	            const gamma = getXMLValue(xmpBlock, 'hdrgm:Gamma', '1');
	            const offsetSDR = getXMLValue(xmpBlock, 'hdrgm:OffsetSDR', '0.015625');
	            const offsetHDR = getXMLValue(xmpBlock, 'hdrgm:OffsetHDR', '0.015625');
	            // These are always attributes, so we can use a simpler regex
	            const hdrCapacityMinMatch = /hdrgm:HDRCapacityMin="([^"]*)"/.exec(xmpBlock);
	            const hdrCapacityMin = hdrCapacityMinMatch ? hdrCapacityMinMatch[1] : '0';
	            const hdrCapacityMaxMatch = /hdrgm:HDRCapacityMax="([^"]*)"/.exec(xmpBlock);
	            if (!hdrCapacityMaxMatch) throw new Error('Incomplete gainmap metadata');
	            const hdrCapacityMax = hdrCapacityMaxMatch[1];
	            return {
	                gainMapMin: Array.isArray(gainMapMin) ? gainMapMin.map((v)=>parseFloat(v)) : [
	                    parseFloat(gainMapMin),
	                    parseFloat(gainMapMin),
	                    parseFloat(gainMapMin)
	                ],
	                gainMapMax: Array.isArray(gainMapMax) ? gainMapMax.map((v)=>parseFloat(v)) : [
	                    parseFloat(gainMapMax),
	                    parseFloat(gainMapMax),
	                    parseFloat(gainMapMax)
	                ],
	                gamma: Array.isArray(gamma) ? gamma.map((v)=>parseFloat(v)) : [
	                    parseFloat(gamma),
	                    parseFloat(gamma),
	                    parseFloat(gamma)
	                ],
	                offsetSdr: Array.isArray(offsetSDR) ? offsetSDR.map((v)=>parseFloat(v)) : [
	                    parseFloat(offsetSDR),
	                    parseFloat(offsetSDR),
	                    parseFloat(offsetSDR)
	                ],
	                offsetHdr: Array.isArray(offsetHDR) ? offsetHDR.map((v)=>parseFloat(v)) : [
	                    parseFloat(offsetHDR),
	                    parseFloat(offsetHDR),
	                    parseFloat(offsetHDR)
	                ],
	                hdrCapacityMin: parseFloat(hdrCapacityMin),
	                hdrCapacityMax: parseFloat(hdrCapacityMax)
	            };
	        } catch (e) {
	        // Continue searching for another xmpmeta block if this one fails
	        }
	        start = str.indexOf('<x:xmpmeta', end);
	    }
	};
	/**
	 * MPF Extractor (Multi Picture Format Extractor)
	 * By Henrik S Nilsson 2019
	 *
	 * Extracts images stored in images based on the MPF format (found here: https://www.cipa.jp/e/std/std-sec.html
	 * under "CIPA DC-007-Translation-2021 Multi-Picture Format"
	 *
	 * Overly commented, and without intention of being complete or production ready.
	 * Created to extract depth maps from iPhone images, and to learn about image metadata.
	 * Kudos to: Phil Harvey (exiftool), Jaume Sanchez (android-lens-blur-depth-extractor)
	 */ class MPFExtractor {
	    extract(imageArrayBuffer) {
	        return new Promise((resolve, reject)=>{
	            const debug = this.options.debug;
	            const dataView = new DataView(imageArrayBuffer.buffer);
	            // If you're executing this line on a big endian machine, it'll be reversed.
	            // bigEnd further down though, refers to the endianness of the image itself.
	            if (dataView.getUint16(0) !== 0xffd8) {
	                reject(new Error('Not a valid jpeg'));
	                return;
	            }
	            const length = dataView.byteLength;
	            let offset = 2;
	            let loops = 0;
	            let marker; // APP# marker
	            while(offset < length){
	                if (++loops > 250) {
	                    reject(new Error(`Found no marker after ${loops} loops 😵`));
	                    return;
	                }
	                if (dataView.getUint8(offset) !== 0xff) {
	                    reject(new Error(`Not a valid marker at offset 0x${offset.toString(16)}, found: 0x${dataView.getUint8(offset).toString(16)}`));
	                    return;
	                }
	                marker = dataView.getUint8(offset + 1);
	                if (debug) console.log(`Marker: ${marker.toString(16)}`);
	                if (marker === 0xe2) {
	                    if (debug) console.log('Found APP2 marker (0xffe2)');
	                    // Works for iPhone 8 Plus, X, and XSMax. Or any photos of MPF format.
	                    // Great way to visualize image information in html is using Exiftool. E.g.:
	                    // ./exiftool.exe -htmldump -wantTrailer photo.jpg > photo.html
	                    const formatPt = offset + 4;
	                    /*
	                     *  Structure of the MP Format Identifier
	                     *
	                     *  Offset Addr.  | Code (Hex)  | Description
	                     *  +00             ff            Marker Prefix      <-- offset
	                     *  +01             e2            APP2
	                     *  +02             #n            APP2 Field Length
	                     *  +03             #n            APP2 Field Length
	                     *  +04             4d            'M'                <-- formatPt
	                     *  +05             50            'P'
	                     *  +06             46            'F'
	                     *  +07             00            NULL
	                     *                                                   <-- tiffOffset
	                     */ if (dataView.getUint32(formatPt) === 0x4d504600) {
	                        // Found MPF tag, so we start dig out sub images
	                        const tiffOffset = formatPt + 4;
	                        let bigEnd; // Endianness from TIFF header
	                        // Test for TIFF validity and endianness
	                        // 0x4949 and 0x4D4D ('II' and 'MM') marks Little Endian and Big Endian
	                        if (dataView.getUint16(tiffOffset) === 0x4949) {
	                            bigEnd = false;
	                        } else if (dataView.getUint16(tiffOffset) === 0x4d4d) {
	                            bigEnd = true;
	                        } else {
	                            reject(new Error('No valid endianness marker found in TIFF header'));
	                            return;
	                        }
	                        if (dataView.getUint16(tiffOffset + 2, !bigEnd) !== 0x002a) {
	                            reject(new Error('Not valid TIFF data! (no 0x002A marker)'));
	                            return;
	                        }
	                        // 32 bit number stating the offset from the start of the 8 Byte MP Header
	                        // to MP Index IFD Least possible value is thus 8 (means 0 offset)
	                        const firstIFDOffset = dataView.getUint32(tiffOffset + 4, !bigEnd);
	                        if (firstIFDOffset < 0x00000008) {
	                            reject(new Error('Not valid TIFF data! (First offset less than 8)'));
	                            return;
	                        }
	                        // Move ahead to MP Index IFD
	                        // Assume we're at the first IFD, so firstIFDOffset points to
	                        // MP Index IFD and not MP Attributes IFD. (If we try extract from a sub image,
	                        // we fail silently here due to this assumption)
	                        // Count (2 Byte) | MP Index Fields a.k.a. MP Entries (count * 12 Byte) | Offset of Next IFD (4 Byte)
	                        const dirStart = tiffOffset + firstIFDOffset; // Start of IFD (Image File Directory)
	                        const count = dataView.getUint16(dirStart, !bigEnd); // Count of MPEntries (2 Byte)
	                        // Extract info from MPEntries (starting after Count)
	                        const entriesStart = dirStart + 2;
	                        let numberOfImages = 0;
	                        for(let i = entriesStart; i < entriesStart + 12 * count; i += 12){
	                            // Each entry is 12 Bytes long
	                            // Check MP Index IFD tags, here we only take tag 0xb001 = Number of images
	                            if (dataView.getUint16(i, !bigEnd) === 0xb001) {
	                                // stored in Last 4 bytes of its 12 Byte entry.
	                                numberOfImages = dataView.getUint32(i + 8, !bigEnd);
	                            }
	                        }
	                        const nextIFDOffsetLen = 4; // 4 Byte offset field that appears after MP Index IFD tags
	                        const MPImageListValPt = dirStart + 2 + count * 12 + nextIFDOffsetLen;
	                        const images = [];
	                        for(let i = MPImageListValPt; i < MPImageListValPt + numberOfImages * 16; i += 16){
	                            const image = {
	                                MPType: dataView.getUint32(i, !bigEnd),
	                                size: dataView.getUint32(i + 4, !bigEnd),
	                                // This offset is specified relative to the address of the MP Endian
	                                // field in the MP Header, unless the image is a First Individual Image,
	                                // in which case the value of the offset shall be NULL (0x00000000).
	                                dataOffset: dataView.getUint32(i + 8, !bigEnd),
	                                dependantImages: dataView.getUint32(i + 12, !bigEnd),
	                                start: -1,
	                                end: -1,
	                                isFII: false
	                            };
	                            if (!image.dataOffset) {
	                                // dataOffset is 0x00000000 for First Individual Image
	                                image.start = 0;
	                                image.isFII = true;
	                            } else {
	                                image.start = tiffOffset + image.dataOffset;
	                                image.isFII = false;
	                            }
	                            image.end = image.start + image.size;
	                            images.push(image);
	                        }
	                        if (this.options.extractNonFII && images.length) {
	                            const bufferBlob = new Blob([
	                                dataView
	                            ]);
	                            const imgs = [];
	                            for (const image of images){
	                                if (image.isFII && !this.options.extractFII) {
	                                    continue; // Skip FII
	                                }
	                                const imageBlob = bufferBlob.slice(image.start, image.end + 1, 'image/jpeg');
	                                // we don't need this
	                                // const imageUrl = URL.createObjectURL(imageBlob)
	                                // image.img = document.createElement('img')
	                                // image.img.src = imageUrl
	                                imgs.push(imageBlob);
	                            }
	                            resolve(imgs);
	                        }
	                    }
	                }
	                offset += 2 + dataView.getUint16(offset + 2);
	            }
	        });
	    }
	    constructor(options){
	        this.options = {
	            debug: options && options.debug !== undefined ? options.debug : false,
	            extractFII: options && options.extractFII !== undefined ? options.extractFII : true,
	            extractNonFII: options && options.extractNonFII !== undefined ? options.extractNonFII : true
	        };
	    }
	}
	/**
	 * Extracts XMP Metadata and the gain map recovery image
	 * from a single JPEG file.
	 *
	 * @category Decoding Functions
	 * @group Decoding Functions
	 * @param jpegFile an `Uint8Array` containing and encoded JPEG file
	 * @returns an sdr `Uint8Array` compressed in JPEG, a gainMap `Uint8Array` compressed in JPEG and the XMP parsed XMP metadata
	 * @throws Error if XMP Metadata is not found
	 * @throws Error if Gain map image is not found
	 * @example
	 * import { FileLoader } from 'three'
	 * import { extractGainmapFromJPEG } from '@monogrid/gainmap-js'
	 *
	 * const jpegFile = await new FileLoader()
	 *  .setResponseType('arraybuffer')
	 *  .loadAsync('image.jpg')
	 *
	 * const { sdr, gainMap, metadata } = extractGainmapFromJPEG(jpegFile)
	 */ const extractGainmapFromJPEG = async (jpegFile)=>{
	    const metadata = extractXMP(jpegFile);
	    if (!metadata) throw new XMPMetadataNotFoundError('Gain map XMP metadata not found');
	    const mpfExtractor = new MPFExtractor({
	        extractFII: true,
	        extractNonFII: true
	    });
	    const images = await mpfExtractor.extract(jpegFile);
	    if (images.length !== 2) throw new GainMapNotFoundError('Gain map recovery image not found');
	    return {
	        sdr: new Uint8Array(await images[0].arrayBuffer()),
	        gainMap: new Uint8Array(await images[1].arrayBuffer()),
	        metadata
	    };
	};
	/**
	 * private function, async get image from blob
	 *
	 * @param blob
	 * @returns
	 */ const getHTMLImageFromBlob = (blob)=>{
	    return new Promise((resolve, reject)=>{
	        const img = document.createElement('img');
	        img.onload = ()=>{
	            resolve(img);
	        };
	        img.onerror = (e)=>{
	            reject(e);
	        };
	        img.src = URL.createObjectURL(blob);
	    });
	};
	class LoaderBase extends Loader {
	    /**
	     * Specify the renderer to use when rendering the gain map
	     *
	     * @param renderer
	     * @returns
	     */ setRenderer(renderer) {
	        this._renderer = renderer;
	        return this;
	    }
	    /**
	     * Specify the renderTarget options to use when rendering the gain map
	     *
	     * @param options
	     * @returns
	     */ setRenderTargetOptions(options) {
	        this._renderTargetOptions = options;
	        return this;
	    }
	    /**
	     * @private
	     * @returns
	     */ prepareQuadRenderer() {
	        if (!this._renderer) console.warn('WARNING: An existing WebGL Renderer was not passed to this Loader constructor or in setRenderer, the result of this Loader will need to be converted to a Data Texture with toDataTexture() before you can use it in your renderer.');
	        // temporary values
	        const material = new GainMapDecoderMaterial({
	            gainMapMax: [
	                1,
	                1,
	                1
	            ],
	            gainMapMin: [
	                0,
	                0,
	                0
	            ],
	            gamma: [
	                1,
	                1,
	                1
	            ],
	            offsetHdr: [
	                1,
	                1,
	                1
	            ],
	            offsetSdr: [
	                1,
	                1,
	                1
	            ],
	            hdrCapacityMax: 1,
	            hdrCapacityMin: 0,
	            maxDisplayBoost: 1,
	            gainMap: new Texture$1(),
	            sdr: new Texture$1()
	        });
	        return new QuadRenderer({
	            width: 16,
	            height: 16,
	            type: HalfFloatType,
	            colorSpace: LinearSRGBColorSpace,
	            material,
	            renderer: this._renderer,
	            renderTargetOptions: this._renderTargetOptions
	        });
	    }
	    /**
	   * @private
	   * @param quadRenderer
	   * @param metadata
	   * @param sdrBuffer
	   * @param gainMapBuffer
	   */ async render(quadRenderer, metadata, sdrBuffer, gainMapBuffer) {
	        // this is optional, will render a black gain-map if not present
	        const gainMapBlob = gainMapBuffer ? new Blob([
	            gainMapBuffer
	        ], {
	            type: 'image/jpeg'
	        }) : undefined;
	        const sdrBlob = new Blob([
	            sdrBuffer
	        ], {
	            type: 'image/jpeg'
	        });
	        let sdrImage;
	        let gainMapImage;
	        let needsFlip = false;
	        if (typeof createImageBitmap === 'undefined') {
	            const res = await Promise.all([
	                gainMapBlob ? getHTMLImageFromBlob(gainMapBlob) : Promise.resolve(undefined),
	                getHTMLImageFromBlob(sdrBlob)
	            ]);
	            gainMapImage = res[0];
	            sdrImage = res[1];
	            needsFlip = true;
	        } else {
	            const res = await Promise.all([
	                gainMapBlob ? createImageBitmap(gainMapBlob, {
	                    imageOrientation: 'flipY'
	                }) : Promise.resolve(undefined),
	                createImageBitmap(sdrBlob, {
	                    imageOrientation: 'flipY'
	                })
	            ]);
	            gainMapImage = res[0];
	            sdrImage = res[1];
	        }
	        const gainMap = new Texture$1(gainMapImage || new ImageData(2, 2), UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, 1, LinearSRGBColorSpace);
	        gainMap.flipY = needsFlip;
	        gainMap.needsUpdate = true;
	        const sdr = new Texture$1(sdrImage, UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearMipMapLinearFilter, RGBAFormat, UnsignedByteType, 1, SRGBColorSpace);
	        sdr.flipY = needsFlip;
	        sdr.needsUpdate = true;
	        quadRenderer.width = sdrImage.width;
	        quadRenderer.height = sdrImage.height;
	        quadRenderer.material.gainMap = gainMap;
	        quadRenderer.material.sdr = sdr;
	        quadRenderer.material.gainMapMin = metadata.gainMapMin;
	        quadRenderer.material.gainMapMax = metadata.gainMapMax;
	        quadRenderer.material.offsetHdr = metadata.offsetHdr;
	        quadRenderer.material.offsetSdr = metadata.offsetSdr;
	        quadRenderer.material.gamma = metadata.gamma;
	        quadRenderer.material.hdrCapacityMin = metadata.hdrCapacityMin;
	        quadRenderer.material.hdrCapacityMax = metadata.hdrCapacityMax;
	        quadRenderer.material.maxDisplayBoost = Math.pow(2, metadata.hdrCapacityMax);
	        quadRenderer.material.needsUpdate = true;
	        quadRenderer.render();
	    }
	    /**
	     *
	     * @param renderer
	     * @param manager
	     */ constructor(renderer, manager){
	        super(manager);
	        if (renderer) this._renderer = renderer;
	        this._internalLoadingManager = new LoadingManager();
	    }
	}
	/**
	 * A Three.js Loader for a JPEG with embedded gainmap metadata.
	 *
	 * @category Loaders
	 * @group Loaders
	 *
	 * @example
	 * import { HDRJPGLoader } from '@monogrid/gainmap-js'
	 * import {
	 *   EquirectangularReflectionMapping,
	 *   LinearFilter,
	 *   Mesh,
	 *   MeshBasicMaterial,
	 *   PerspectiveCamera,
	 *   PlaneGeometry,
	 *   Scene,
	 *   WebGLRenderer
	 * } from 'three'
	 *
	 * const renderer = new WebGLRenderer()
	 *
	 * const loader = new HDRJPGLoader(renderer)
	 *
	 * const result = await loader.loadAsync('gainmap.jpeg')
	 * // `result` can be used to populate a Texture
	 *
	 * const scene = new Scene()
	 * const mesh = new Mesh(
	 *   new PlaneGeometry(),
	 *   new MeshBasicMaterial({ map: result.renderTarget.texture })
	 * )
	 * scene.add(mesh)
	 * renderer.render(scene, new PerspectiveCamera())
	 *
	 * // Starting from three.js r159
	 * // `result.renderTarget.texture` can
	 * // also be used as Equirectangular scene background
	 * //
	 * // it was previously needed to convert it
	 * // to a DataTexture with `result.toDataTexture()`
	 * scene.background = result.renderTarget.texture
	 * scene.background.mapping = EquirectangularReflectionMapping
	 *
	 * // result must be manually disposed
	 * // when you are done using it
	 * result.dispose()
	 *
	 */ class HDRJPGLoader extends LoaderBase {
	    /**
	     * Loads a JPEG containing gain map metadata
	     * Renders a normal SDR image if gainmap data is not found
	     *
	     * @param url An array in the form of [sdr.jpg, gainmap.jpg, metadata.json]
	     * @param onLoad Load complete callback, will receive the result
	     * @param onProgress Progress callback, will receive a {@link ProgressEvent}
	     * @param onError Error callback
	     * @returns
	     */ load(url, onLoad, onProgress, onError) {
	        const quadRenderer = this.prepareQuadRenderer();
	        const loader = new FileLoader(this._internalLoadingManager);
	        loader.setResponseType('arraybuffer');
	        loader.setRequestHeader(this.requestHeader);
	        loader.setPath(this.path);
	        loader.setWithCredentials(this.withCredentials);
	        this.manager.itemStart(url);
	        loader.load(url, async (jpeg)=>{
	            /* istanbul ignore if
	             this condition exists only because of three.js types + strict mode
	            */ if (typeof jpeg === 'string') throw new Error('Invalid buffer, received [string], was expecting [ArrayBuffer]');
	            const jpegBuffer = new Uint8Array(jpeg);
	            let sdrJPEG;
	            let gainMapJPEG;
	            let metadata;
	            try {
	                const extractionResult = await extractGainmapFromJPEG(jpegBuffer);
	                // gain map is successfully reconstructed
	                sdrJPEG = extractionResult.sdr;
	                gainMapJPEG = extractionResult.gainMap;
	                metadata = extractionResult.metadata;
	            } catch (e) {
	                // render the SDR version if this is not a gainmap
	                if (e instanceof XMPMetadataNotFoundError || e instanceof GainMapNotFoundError) {
	                    console.warn(`Failure to reconstruct an HDR image from ${url}: Gain map metadata not found in the file, HDRJPGLoader will render the SDR jpeg`);
	                    metadata = {
	                        gainMapMin: [
	                            0,
	                            0,
	                            0
	                        ],
	                        gainMapMax: [
	                            1,
	                            1,
	                            1
	                        ],
	                        gamma: [
	                            1,
	                            1,
	                            1
	                        ],
	                        hdrCapacityMin: 0,
	                        hdrCapacityMax: 1,
	                        offsetHdr: [
	                            0,
	                            0,
	                            0
	                        ],
	                        offsetSdr: [
	                            0,
	                            0,
	                            0
	                        ]
	                    };
	                    sdrJPEG = jpegBuffer;
	                } else {
	                    throw e;
	                }
	            }
	            // solves #16
	            try {
	                await this.render(quadRenderer, metadata, sdrJPEG, gainMapJPEG);
	            } catch (error) {
	                this.manager.itemError(url);
	                if (typeof onError === 'function') onError(error);
	                quadRenderer.disposeOnDemandRenderer();
	                return;
	            }
	            if (typeof onLoad === 'function') onLoad(quadRenderer);
	            this.manager.itemEnd(url);
	            quadRenderer.disposeOnDemandRenderer();
	        }, onProgress, (error)=>{
	            this.manager.itemError(url);
	            if (typeof onError === 'function') onError(error);
	        });
	        return quadRenderer;
	    }
	}

	// https://github.com/mrdoob/three.js/issues/5552
	// http://en.wikipedia.org/wiki/RGBE_image_format
	class RGBELoader extends DataTextureLoader {
	    // adapted from http://www.graphics.cornell.edu/~bjw/rgbe.html
	    parse(buffer) {
	        const /* default error routine.  change this to change error handling */ rgbe_read_error = 1, rgbe_write_error = 2, rgbe_format_error = 3, rgbe_memory_error = 4, rgbe_error = function(rgbe_error_code, msg) {
	            switch(rgbe_error_code){
	                case rgbe_read_error:
	                    throw new Error('THREE.RGBELoader: Read Error: ' + (msg || ''));
	                case rgbe_write_error:
	                    throw new Error('THREE.RGBELoader: Write Error: ' + (msg || ''));
	                case rgbe_format_error:
	                    throw new Error('THREE.RGBELoader: Bad File Format: ' + (msg || ''));
	                default:
	                case rgbe_memory_error:
	                    throw new Error('THREE.RGBELoader: Memory Error: ' + (msg || ''));
	            }
	        }, /* offsets to red, green, and blue components in a data (float) pixel */ //RGBE_DATA_RED = 0,
	        //RGBE_DATA_GREEN = 1,
	        //RGBE_DATA_BLUE = 2,
	        /* number of floats per pixel, use 4 since stored in rgba image format */ //RGBE_DATA_SIZE = 4,
	        /* flags indicating which fields in an rgbe_header_info are valid */ RGBE_VALID_PROGRAMTYPE = 1, RGBE_VALID_FORMAT = 2, RGBE_VALID_DIMENSIONS = 4, NEWLINE = '\n', fgets = function(buffer, lineLimit, consume) {
	            const chunkSize = 128;
	            lineLimit = !lineLimit ? 1024 : lineLimit;
	            let p = buffer.pos, i = -1, len = 0, s = '', chunk = String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
	            while(0 > (i = chunk.indexOf(NEWLINE)) && len < lineLimit && p < buffer.byteLength){
	                s += chunk;
	                len += chunk.length;
	                p += chunkSize;
	                chunk += String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
	            }
	            if (-1 < i) {
	                /*for (i=l-1; i>=0; i--) {
							byteCode = m.charCodeAt(i);
							if (byteCode > 0x7f && byteCode <= 0x7ff) byteLen++;
							else if (byteCode > 0x7ff && byteCode <= 0xffff) byteLen += 2;
							if (byteCode >= 0xDC00 && byteCode <= 0xDFFF) i--; //trail surrogate
						}*/ buffer.pos += len + i + 1;
	                return s + chunk.slice(0, i);
	            }
	            return false;
	        }, /* minimal header reading.  modify if you want to parse more information */ RGBE_ReadHeader = function(buffer) {
	            // regexes to parse header info fields
	            const magic_token_re = /^#\?(\S+)/, gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, format_re = /^\s*FORMAT=(\S+)\s*$/, dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, // RGBE format header struct
	            header = {
	                valid: 0,
	                /* indicate which fields are valid */ string: '',
	                /* the actual header string */ comments: '',
	                /* comments found in header */ programtype: 'RGBE',
	                /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */ format: '',
	                /* RGBE format, default 32-bit_rle_rgbe */ gamma: 1.0,
	                /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */ exposure: 1.0,
	                /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */ width: 0,
	                height: 0 /* image dimensions, width/height */ 
	            };
	            let line, match;
	            if (buffer.pos >= buffer.byteLength || !(line = fgets(buffer))) {
	                rgbe_error(rgbe_read_error, 'no header found');
	            }
	            /* if you want to require the magic token then uncomment the next line */ if (!(match = line.match(magic_token_re))) {
	                rgbe_error(rgbe_format_error, 'bad initial token');
	            }
	            header.valid |= RGBE_VALID_PROGRAMTYPE;
	            header.programtype = match[1];
	            header.string += line + '\n';
	            while(true){
	                line = fgets(buffer);
	                if (false === line) break;
	                header.string += line + '\n';
	                if ('#' === line.charAt(0)) {
	                    header.comments += line + '\n';
	                    continue; // comment line
	                }
	                if (match = line.match(gamma_re)) {
	                    header.gamma = parseFloat(match[1]);
	                }
	                if (match = line.match(exposure_re)) {
	                    header.exposure = parseFloat(match[1]);
	                }
	                if (match = line.match(format_re)) {
	                    header.valid |= RGBE_VALID_FORMAT;
	                    header.format = match[1]; //'32-bit_rle_rgbe';
	                }
	                if (match = line.match(dimensions_re)) {
	                    header.valid |= RGBE_VALID_DIMENSIONS;
	                    header.height = parseInt(match[1], 10);
	                    header.width = parseInt(match[2], 10);
	                }
	                if (header.valid & RGBE_VALID_FORMAT && header.valid & RGBE_VALID_DIMENSIONS) break;
	            }
	            if (!(header.valid & RGBE_VALID_FORMAT)) {
	                rgbe_error(rgbe_format_error, 'missing format specifier');
	            }
	            if (!(header.valid & RGBE_VALID_DIMENSIONS)) {
	                rgbe_error(rgbe_format_error, 'missing image size specifier');
	            }
	            return header;
	        }, RGBE_ReadPixels_RLE = function(buffer, w, h) {
	            const scanline_width = w;
	            if (scanline_width < 8 || scanline_width > 0x7fff || // this file is not run length encoded
	            2 !== buffer[0] || 2 !== buffer[1] || buffer[2] & 0x80) {
	                // return the flat buffer
	                return new Uint8Array(buffer);
	            }
	            if (scanline_width !== (buffer[2] << 8 | buffer[3])) {
	                rgbe_error(rgbe_format_error, 'wrong scanline width');
	            }
	            const data_rgba = new Uint8Array(4 * w * h);
	            if (!data_rgba.length) {
	                rgbe_error(rgbe_memory_error, 'unable to allocate buffer space');
	            }
	            let offset = 0, pos = 0;
	            const ptr_end = 4 * scanline_width;
	            const rgbeStart = new Uint8Array(4);
	            const scanline_buffer = new Uint8Array(ptr_end);
	            let num_scanlines = h;
	            // read in each successive scanline
	            while(num_scanlines > 0 && pos < buffer.byteLength){
	                if (pos + 4 > buffer.byteLength) {
	                    rgbe_error(rgbe_read_error);
	                }
	                rgbeStart[0] = buffer[pos++];
	                rgbeStart[1] = buffer[pos++];
	                rgbeStart[2] = buffer[pos++];
	                rgbeStart[3] = buffer[pos++];
	                if (2 != rgbeStart[0] || 2 != rgbeStart[1] || (rgbeStart[2] << 8 | rgbeStart[3]) != scanline_width) {
	                    rgbe_error(rgbe_format_error, 'bad rgbe scanline format');
	                }
	                // read each of the four channels for the scanline into the buffer
	                // first red, then green, then blue, then exponent
	                let ptr = 0, count;
	                while(ptr < ptr_end && pos < buffer.byteLength){
	                    count = buffer[pos++];
	                    const isEncodedRun = count > 128;
	                    if (isEncodedRun) count -= 128;
	                    if (0 === count || ptr + count > ptr_end) {
	                        rgbe_error(rgbe_format_error, 'bad scanline data');
	                    }
	                    if (isEncodedRun) {
	                        // a (encoded) run of the same value
	                        const byteValue = buffer[pos++];
	                        for(let i = 0; i < count; i++){
	                            scanline_buffer[ptr++] = byteValue;
	                        }
	                    //ptr += count;
	                    } else {
	                        // a literal-run
	                        scanline_buffer.set(buffer.subarray(pos, pos + count), ptr);
	                        ptr += count;
	                        pos += count;
	                    }
	                }
	                // now convert data from buffer into rgba
	                // first red, then green, then blue, then exponent (alpha)
	                const l = scanline_width; //scanline_buffer.byteLength;
	                for(let i = 0; i < l; i++){
	                    let off = 0;
	                    data_rgba[offset] = scanline_buffer[i + off];
	                    off += scanline_width; //1;
	                    data_rgba[offset + 1] = scanline_buffer[i + off];
	                    off += scanline_width; //1;
	                    data_rgba[offset + 2] = scanline_buffer[i + off];
	                    off += scanline_width; //1;
	                    data_rgba[offset + 3] = scanline_buffer[i + off];
	                    offset += 4;
	                }
	                num_scanlines--;
	            }
	            return data_rgba;
	        };
	        const RGBEByteToRGBFloat = function(sourceArray, sourceOffset, destArray, destOffset) {
	            const e = sourceArray[sourceOffset + 3];
	            const scale = Math.pow(2.0, e - 128.0) / 255.0;
	            destArray[destOffset + 0] = sourceArray[sourceOffset + 0] * scale;
	            destArray[destOffset + 1] = sourceArray[sourceOffset + 1] * scale;
	            destArray[destOffset + 2] = sourceArray[sourceOffset + 2] * scale;
	            destArray[destOffset + 3] = 1;
	        };
	        const RGBEByteToRGBHalf = function(sourceArray, sourceOffset, destArray, destOffset) {
	            const e = sourceArray[sourceOffset + 3];
	            const scale = Math.pow(2.0, e - 128.0) / 255.0;
	            // clamping to 65504, the maximum representable value in float16
	            destArray[destOffset + 0] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 0] * scale, 65504));
	            destArray[destOffset + 1] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 1] * scale, 65504));
	            destArray[destOffset + 2] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 2] * scale, 65504));
	            destArray[destOffset + 3] = DataUtils.toHalfFloat(1);
	        };
	        const byteArray = new Uint8Array(buffer);
	        byteArray.pos = 0;
	        const rgbe_header_info = RGBE_ReadHeader(byteArray);
	        const w = rgbe_header_info.width, h = rgbe_header_info.height, image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h);
	        let data, type;
	        let numElements;
	        switch(this.type){
	            case FloatType:
	                numElements = image_rgba_data.length / 4;
	                const floatArray = new Float32Array(numElements * 4);
	                for(let j = 0; j < numElements; j++){
	                    RGBEByteToRGBFloat(image_rgba_data, j * 4, floatArray, j * 4);
	                }
	                data = floatArray;
	                type = FloatType;
	                break;
	            case HalfFloatType:
	                numElements = image_rgba_data.length / 4;
	                const halfArray = new Uint16Array(numElements * 4);
	                for(let j = 0; j < numElements; j++){
	                    RGBEByteToRGBHalf(image_rgba_data, j * 4, halfArray, j * 4);
	                }
	                data = halfArray;
	                type = HalfFloatType;
	                break;
	            default:
	                throw new Error('THREE.RGBELoader: Unsupported type: ' + this.type);
	        }
	        return {
	            width: w,
	            height: h,
	            data: data,
	            header: rgbe_header_info.string,
	            gamma: rgbe_header_info.gamma,
	            exposure: rgbe_header_info.exposure,
	            type: type
	        };
	    }
	    setDataType(value) {
	        this.type = value;
	        return this;
	    }
	    load(url, onLoad, onProgress, onError) {
	        function onLoadCallback(texture, texData) {
	            switch(texture.type){
	                case FloatType:
	                case HalfFloatType:
	                    texture.colorSpace = LinearSRGBColorSpace;
	                    texture.minFilter = LinearFilter;
	                    texture.magFilter = LinearFilter;
	                    texture.generateMipmaps = false;
	                    texture.flipY = true;
	                    break;
	            }
	            if (onLoad) onLoad(texture, texData);
	        }
	        return super.load(url, onLoadCallback, onProgress, onError);
	    }
	    constructor(manager){
	        super(manager);
	        this.type = HalfFloatType;
	    }
	}

	const legacy = {
	    topLight: {
	        intensity: 500,
	        position: [
	            0.418,
	            16.199,
	            0.300
	        ]
	    },
	    room: {
	        position: [
	            -0.757,
	            13.219,
	            0.717
	        ],
	        scale: [
	            31.713,
	            28.305,
	            28.591
	        ]
	    },
	    boxes: [
	        {
	            position: [
	                -10.906,
	                2.009,
	                1.846
	            ],
	            rotation: -0.195,
	            scale: [
	                2.328,
	                7.905,
	                4.651
	            ]
	        },
	        {
	            position: [
	                -5.607,
	                -0.754,
	                -0.758
	            ],
	            rotation: 0.994,
	            scale: [
	                1.970,
	                1.534,
	                3.955
	            ]
	        },
	        {
	            position: [
	                6.167,
	                0.857,
	                7.803
	            ],
	            rotation: 0.561,
	            scale: [
	                3.927,
	                6.285,
	                3.687
	            ]
	        },
	        {
	            position: [
	                -2.017,
	                0.018,
	                6.124
	            ],
	            rotation: 0.333,
	            scale: [
	                2.002,
	                4.566,
	                2.064
	            ]
	        },
	        {
	            position: [
	                2.291,
	                -0.756,
	                -2.621
	            ],
	            rotation: -0.286,
	            scale: [
	                1.546,
	                1.552,
	                1.496
	            ]
	        },
	        {
	            position: [
	                -2.193,
	                -0.369,
	                -5.547
	            ],
	            rotation: 0.516,
	            scale: [
	                3.875,
	                3.487,
	                2.986
	            ]
	        }
	    ],
	    lights: [
	        {
	            intensity: 50,
	            position: [
	                -16.116,
	                14.37,
	                8.208
	            ],
	            scale: [
	                0.1,
	                2.428,
	                2.739
	            ]
	        },
	        {
	            intensity: 50,
	            position: [
	                -16.109,
	                18.021,
	                -8.207
	            ],
	            scale: [
	                0.1,
	                2.425,
	                2.751
	            ]
	        },
	        {
	            intensity: 17,
	            position: [
	                14.904,
	                12.198,
	                -1.832
	            ],
	            scale: [
	                0.15,
	                4.265,
	                6.331
	            ]
	        },
	        {
	            intensity: 43,
	            position: [
	                -0.462,
	                8.89,
	                14.520
	            ],
	            scale: [
	                4.38,
	                5.441,
	                0.088
	            ]
	        },
	        {
	            intensity: 20,
	            position: [
	                3.235,
	                11.486,
	                -12.541
	            ],
	            scale: [
	                2.5,
	                2.0,
	                0.1
	            ]
	        },
	        {
	            intensity: 100,
	            position: [
	                0.0,
	                20.0,
	                0.0
	            ],
	            scale: [
	                1.0,
	                0.1,
	                1.0
	            ]
	        }
	    ]
	};
	const neutral = {
	    topLight: {
	        intensity: 400,
	        position: [
	            0.5,
	            14.0,
	            0.5
	        ]
	    },
	    room: {
	        position: [
	            0.0,
	            13.2,
	            0.0
	        ],
	        scale: [
	            31.5,
	            28.5,
	            31.5
	        ]
	    },
	    boxes: [
	        {
	            position: [
	                -10.906,
	                -1,
	                1.846
	            ],
	            rotation: -0.195,
	            scale: [
	                2.328,
	                7.905,
	                4.651
	            ]
	        },
	        {
	            position: [
	                -5.607,
	                -0.754,
	                -0.758
	            ],
	            rotation: 0.994,
	            scale: [
	                1.970,
	                1.534,
	                3.955
	            ]
	        },
	        {
	            position: [
	                6.167,
	                -0.16,
	                7.803
	            ],
	            rotation: 0.561,
	            scale: [
	                3.927,
	                6.285,
	                3.687
	            ]
	        },
	        {
	            position: [
	                -2.017,
	                0.018,
	                6.124
	            ],
	            rotation: 0.333,
	            scale: [
	                2.002,
	                4.566,
	                2.064
	            ]
	        },
	        {
	            position: [
	                2.291,
	                -0.756,
	                -2.621
	            ],
	            rotation: -0.286,
	            scale: [
	                1.546,
	                1.552,
	                1.496
	            ]
	        },
	        {
	            position: [
	                -2.193,
	                -0.369,
	                -5.547
	            ],
	            rotation: 0.516,
	            scale: [
	                3.875,
	                3.487,
	                2.986
	            ]
	        }
	    ],
	    lights: [
	        {
	            intensity: 80,
	            position: [
	                -14,
	                10.0,
	                8.0
	            ],
	            scale: [
	                0.1,
	                2.5,
	                2.5
	            ]
	        },
	        {
	            intensity: 80,
	            position: [
	                -14,
	                14.0,
	                -4
	            ],
	            scale: [
	                0.1,
	                2.5,
	                2.5
	            ]
	        },
	        {
	            intensity: 23,
	            position: [
	                14.0,
	                12.0,
	                0.0
	            ],
	            scale: [
	                0.1,
	                5.0,
	                5.0
	            ]
	        },
	        {
	            intensity: 16,
	            position: [
	                0.0,
	                9.0,
	                14.0
	            ],
	            scale: [
	                5.0,
	                5.0,
	                0.1
	            ]
	        },
	        {
	            intensity: 80,
	            position: [
	                7.0,
	                8.0,
	                -14
	            ],
	            scale: [
	                2.5,
	                2.5,
	                0.1
	            ]
	        },
	        {
	            intensity: 80,
	            position: [
	                -7,
	                16.0,
	                -14
	            ],
	            scale: [
	                2.5,
	                2.5,
	                0.1
	            ]
	        },
	        {
	            intensity: 1,
	            position: [
	                0.0,
	                20.0,
	                0.0
	            ],
	            scale: [
	                0.1,
	                0.1,
	                0.1
	            ]
	        }
	    ]
	};
	class EnvironmentScene extends Scene {
	    createAreaLightMaterial(intensity) {
	        const material = new MeshBasicMaterial();
	        material.color.setScalar(intensity);
	        return material;
	    }
	    constructor(name){
	        super();
	        this.position.y = -3.5;
	        const geometry = new BoxGeometry();
	        geometry.deleteAttribute('uv');
	        const roomMaterial = new MeshStandardMaterial({
	            metalness: 0,
	            side: BackSide
	        });
	        const boxMaterial = new MeshStandardMaterial({
	            metalness: 0
	        });
	        const data = name == 'legacy' ? legacy : neutral;
	        const mainLight = new PointLight(0xffffff, data.topLight.intensity, 28, 2);
	        mainLight.position.set(...data.topLight.position);
	        this.add(mainLight);
	        const room = new Mesh(geometry, roomMaterial);
	        room.position.set(...data.room.position);
	        room.scale.set(...data.room.scale);
	        this.add(room);
	        for (const box of data.boxes){
	            const box1 = new Mesh(geometry, boxMaterial);
	            box1.position.set(...box.position);
	            box1.rotation.set(0, box.rotation, 0);
	            box1.scale.set(...box.scale);
	            this.add(box1);
	        }
	        for (const light of data.lights){
	            const light1 = new Mesh(geometry, this.createAreaLightMaterial(light.intensity));
	            light1.position.set(...light.position);
	            light1.scale.set(...light.scale);
	            this.add(light1);
	        }
	    }
	}

	const GENERATED_SIGMA = 0.04;
	const MAX_SAMPLES = 20;
	const HDR_FILE_RE = /\.hdr(\.js)?$/;
	class TextureUtils {
	    ldrLoader(withCredentials) {
	        if (this._ldrLoader == null) {
	            this._ldrLoader = new TextureLoader();
	        }
	        this._ldrLoader.setWithCredentials(withCredentials);
	        return this._ldrLoader;
	    }
	    imageLoader(withCredentials) {
	        if (this._imageLoader == null) {
	            this._imageLoader = new HDRJPGLoader(this.threeRenderer);
	        }
	        this._imageLoader.setWithCredentials(withCredentials);
	        return this._imageLoader;
	    }
	    hdrLoader(withCredentials) {
	        if (this._hdrLoader == null) {
	            this._hdrLoader = new RGBELoader();
	            this._hdrLoader.setDataType(HalfFloatType);
	        }
	        this._hdrLoader.setWithCredentials(withCredentials);
	        return this._hdrLoader;
	    }
	    async getLottieLoader(withCredentials) {
	        if (this._lottieLoader == null) {
	            const { LottieLoader } = await import( this.lottieLoaderUrl);
	            this._lottieLoader = new LottieLoader();
	        }
	        this._lottieLoader.setWithCredentials(withCredentials);
	        return this._lottieLoader;
	    }
	    async loadImage(url, withCredentials) {
	        const texture = await new Promise((resolve, reject)=>this.ldrLoader(withCredentials).load(url, resolve, ()=>{}, reject));
	        texture.name = url;
	        texture.flipY = false;
	        return texture;
	    }
	    async loadLottie(url, quality, withCredentials) {
	        const loader = await this.getLottieLoader(withCredentials);
	        loader.setQuality(quality);
	        const texture = await new Promise((resolve, reject)=>loader.load(url, resolve, ()=>{}, reject));
	        texture.name = url;
	        return texture;
	    }
	    async loadEquirect(url, withCredentials = false, progressCallback = ()=>{}) {
	        try {
	            const isHDR = HDR_FILE_RE.test(url);
	            const loader = isHDR ? this.hdrLoader(withCredentials) : this.imageLoader(withCredentials);
	            const texture = await new Promise((resolve, reject)=>loader.load(url, (result)=>{
	                    const { renderTarget } = result;
	                    if (renderTarget != null) {
	                        const { texture } = renderTarget;
	                        result.dispose(false);
	                        resolve(texture);
	                    } else {
	                        resolve(result);
	                    }
	                }, (event)=>{
	                    progressCallback(event.loaded / event.total * 0.9);
	                }, reject));
	            progressCallback(1.0);
	            texture.name = url;
	            texture.mapping = EquirectangularReflectionMapping;
	            if (!isHDR) {
	                texture.colorSpace = SRGBColorSpace;
	            }
	            return texture;
	        } finally{
	            if (progressCallback) {
	                progressCallback(1);
	            }
	        }
	    }
	 async generateEnvironmentMapAndSkybox(skyboxUrl = null, environmentMapUrl = null, progressCallback = ()=>{}, withCredentials = false) {
	        const useAltEnvironment = environmentMapUrl !== 'legacy';
	        if (environmentMapUrl === 'legacy' || environmentMapUrl === 'neutral') {
	            environmentMapUrl = null;
	        }
	        environmentMapUrl = deserializeUrl(environmentMapUrl);
	        let skyboxLoads = Promise.resolve(null);
	        let environmentMapLoads;
	        if (!!skyboxUrl) {
	            skyboxLoads = this.loadEquirectFromUrl(skyboxUrl, withCredentials, progressCallback);
	        }
	        if (!!environmentMapUrl) {
	            environmentMapLoads = this.loadEquirectFromUrl(environmentMapUrl, withCredentials, progressCallback);
	        } else if (!!skyboxUrl) {
	            environmentMapLoads = this.loadEquirectFromUrl(skyboxUrl, withCredentials, progressCallback);
	        } else {
	            environmentMapLoads = useAltEnvironment ? this.loadGeneratedEnvironmentMapAlt() : this.loadGeneratedEnvironmentMap();
	        }
	        const [environmentMap, skybox] = await Promise.all([
	            environmentMapLoads,
	            skyboxLoads
	        ]);
	        if (environmentMap == null) {
	            throw new Error('Failed to load environment map.');
	        }
	        return {
	            environmentMap,
	            skybox
	        };
	    }
	 async loadEquirectFromUrl(url, withCredentials, progressCallback) {
	        if (!this.skyboxCache.has(url)) {
	            const skyboxMapLoads = this.loadEquirect(url, withCredentials, progressCallback);
	            this.skyboxCache.set(url, skyboxMapLoads);
	        }
	        return this.skyboxCache.get(url);
	    }
	    async GenerateEnvironmentMap(scene, name) {
	        await timePasses();
	        const renderer = this.threeRenderer;
	        const cubeTarget = new WebGLCubeRenderTarget(256, {
	            generateMipmaps: false,
	            type: HalfFloatType,
	            format: RGBAFormat,
	            colorSpace: LinearSRGBColorSpace,
	            depthBuffer: true
	        });
	        const cubeCamera = new CubeCamera(0.1, 100, cubeTarget);
	        const generatedEnvironmentMap = cubeCamera.renderTarget.texture;
	        generatedEnvironmentMap.name = name;
	        const outputColorSpace = renderer.outputColorSpace;
	        const toneMapping = renderer.toneMapping;
	        renderer.toneMapping = NoToneMapping;
	        renderer.outputColorSpace = LinearSRGBColorSpace;
	        cubeCamera.update(renderer, scene);
	        this.blurCubemap(cubeTarget, GENERATED_SIGMA);
	        renderer.toneMapping = toneMapping;
	        renderer.outputColorSpace = outputColorSpace;
	        return generatedEnvironmentMap;
	    }
	 async loadGeneratedEnvironmentMap() {
	        if (this.generatedEnvironmentMap == null) {
	            this.generatedEnvironmentMap = this.GenerateEnvironmentMap(new EnvironmentScene('legacy'), 'legacy');
	        }
	        return this.generatedEnvironmentMap;
	    }
	 async loadGeneratedEnvironmentMapAlt() {
	        if (this.generatedEnvironmentMapAlt == null) {
	            this.generatedEnvironmentMapAlt = this.GenerateEnvironmentMap(new EnvironmentScene('neutral'), 'neutral');
	        }
	        return this.generatedEnvironmentMapAlt;
	    }
	    blurCubemap(cubeTarget, sigma) {
	        if (this.blurMaterial == null) {
	            this.blurMaterial = this.getBlurShader(MAX_SAMPLES);
	            const box = new BoxGeometry();
	            const blurMesh = new Mesh(box, this.blurMaterial);
	            this.blurScene = new Scene();
	            this.blurScene.add(blurMesh);
	        }
	        const tempTarget = cubeTarget.clone();
	        this.halfblur(cubeTarget, tempTarget, sigma, 'latitudinal');
	        this.halfblur(tempTarget, cubeTarget, sigma, 'longitudinal');
	     }
	    halfblur(targetIn, targetOut, sigmaRadians, direction) {
	        const STANDARD_DEVIATIONS = 3;
	        const pixels = targetIn.width;
	        const radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : 2 * Math.PI / (2 * MAX_SAMPLES - 1);
	        const sigmaPixels = sigmaRadians / radiansPerPixel;
	        const samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : MAX_SAMPLES;
	        if (samples > MAX_SAMPLES) {
	            console.warn(`sigmaRadians, ${sigmaRadians}, is too large and will clip, as it requested ${samples} samples when the maximum is set to ${MAX_SAMPLES}`);
	        }
	        const weights = [];
	        let sum = 0;
	        for(let i = 0; i < MAX_SAMPLES; ++i){
	            const x = i / sigmaPixels;
	            const weight = Math.exp(-x * x / 2);
	            weights.push(weight);
	            if (i == 0) {
	                sum += weight;
	            } else if (i < samples) {
	                sum += 2 * weight;
	            }
	        }
	        for(let i = 0; i < weights.length; i++){
	            weights[i] = weights[i] / sum;
	        }
	        const blurUniforms = this.blurMaterial.uniforms;
	        blurUniforms['envMap'].value = targetIn.texture;
	        blurUniforms['samples'].value = samples;
	        blurUniforms['weights'].value = weights;
	        blurUniforms['latitudinal'].value = direction === 'latitudinal';
	        blurUniforms['dTheta'].value = radiansPerPixel;
	        const cubeCamera = new CubeCamera(0.1, 100, targetOut);
	        cubeCamera.update(this.threeRenderer, this.blurScene);
	    }
	    getBlurShader(maxSamples) {
	        const weights = new Float32Array(maxSamples);
	        const poleAxis = new Vector3(0, 1, 0);
	        const shaderMaterial = new ShaderMaterial({
	            name: 'SphericalGaussianBlur',
	            defines: {
	                'n': maxSamples
	            },
	            uniforms: {
	                'envMap': {
	                    value: null
	                },
	                'samples': {
	                    value: 1
	                },
	                'weights': {
	                    value: weights
	                },
	                'latitudinal': {
	                    value: false
	                },
	                'dTheta': {
	                    value: 0
	                },
	                'poleAxis': {
	                    value: poleAxis
	                }
	            },
	            vertexShader:  `
      
      varying vec3 vOutputDirection;
  
      void main() {
  
        vOutputDirection = vec3( position );
        gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
  
      }
    `,
	            fragmentShader:  `
        varying vec3 vOutputDirection;
  
        uniform samplerCube envMap;
        uniform int samples;
        uniform float weights[ n ];
        uniform bool latitudinal;
        uniform float dTheta;
        uniform vec3 poleAxis;
  
        vec3 getSample( float theta, vec3 axis ) {
  
          float cosTheta = cos( theta );
          // Rodrigues' axis-angle rotation
          vec3 sampleDirection = vOutputDirection * cosTheta
            + cross( axis, vOutputDirection ) * sin( theta )
            + axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );
  
          return vec3( textureCube( envMap, sampleDirection ) );
  
        }
  
        void main() {
  
          vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );
  
          if ( all( equal( axis, vec3( 0.0 ) ) ) ) {
  
            axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );
  
          }
  
          axis = normalize( axis );
  
          gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
          gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );
  
          for ( int i = 1; i < n; i++ ) {
  
            if ( i >= samples ) {
  
              break;
  
            }
  
            float theta = dTheta * float( i );
            gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
            gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );
  
          }
        }
      `,
	            blending: NoBlending,
	            depthTest: false,
	            depthWrite: false,
	            side: BackSide
	        });
	        return shaderMaterial;
	    }
	    async dispose() {
	        for (const [, promise] of this.skyboxCache){
	            const skybox = await promise;
	            skybox.dispose();
	        }
	        if (this.generatedEnvironmentMap != null) {
	            (await this.generatedEnvironmentMap).dispose();
	            this.generatedEnvironmentMap = null;
	        }
	        if (this.generatedEnvironmentMapAlt != null) {
	            (await this.generatedEnvironmentMapAlt).dispose();
	            this.generatedEnvironmentMapAlt = null;
	        }
	        if (this.blurMaterial != null) {
	            this.blurMaterial.dispose();
	        }
	    }
	    constructor(threeRenderer){
	        this.threeRenderer = threeRenderer;
	        this.lottieLoaderUrl = '';
	        this._ldrLoader = null;
	        this._imageLoader = null;
	        this._hdrLoader = null;
	        this._lottieLoader = null;
	        this.generatedEnvironmentMap = null;
	        this.generatedEnvironmentMapAlt = null;
	        this.skyboxCache = new Map();
	        this.blurMaterial = null;
	        this.blurScene = null;
	    }
	}

	const DURATION_DECAY = 0.2;
	const LOW_FRAME_DURATION_MS = 40;
	const HIGH_FRAME_DURATION_MS = 60;
	const MAX_AVG_CHANGE_MS = 5;
	const SCALE_STEPS = [
	    1,
	    0.79,
	    0.62,
	    0.5,
	    0.4,
	    0.31,
	    0.25
	];
	const DEFAULT_LAST_STEP = 3;
	const DEFAULT_POWER_PREFERENCE = 'high-performance';
	const COMMERCE_EXPOSURE = 1.3;
	 class Renderer extends EventDispatcher {
	    static get singleton() {
	        if (!this._singleton) {
	            this._singleton = new Renderer({
	                powerPreference: (self.ModelViewerElement || {}).powerPreference || DEFAULT_POWER_PREFERENCE,
	                debug: isDebugMode()
	            });
	        }
	        return this._singleton;
	    }
	    static resetSingleton() {
	        const elements = this._singleton.dispose();
	        for (const element of elements){
	            element.disconnectedCallback();
	        }
	        this._singleton = new Renderer({
	            powerPreference: (self.ModelViewerElement || {}).powerPreference || DEFAULT_POWER_PREFERENCE,
	            debug: isDebugMode()
	        });
	        for (const element of elements){
	            element.connectedCallback();
	        }
	    }
	    get canRender() {
	        return this.threeRenderer != null;
	    }
	    get scaleFactor() {
	        return SCALE_STEPS[this.scaleStep];
	    }
	    set minScale(scale) {
	        let i = 1;
	        while(i < SCALE_STEPS.length){
	            if (SCALE_STEPS[i] < scale) {
	                break;
	            }
	            ++i;
	        }
	        this.lastStep = i - 1;
	    }
	    registerScene(scene) {
	        this.scenes.add(scene);
	        scene.forceRescale();
	        const size = new Vector2();
	        this.threeRenderer.getSize(size);
	        scene.canvas.width = size.x;
	        scene.canvas.height = size.y;
	        if (this.canRender && this.scenes.size > 0) {
	            this.threeRenderer.setAnimationLoop((time, frame)=>this.render(time, frame));
	        }
	    }
	    unregisterScene(scene) {
	        this.scenes.delete(scene);
	        if (this.canvas3D.parentElement === scene.canvas.parentElement) {
	            scene.canvas.parentElement.removeChild(this.canvas3D);
	        }
	        if (this.canRender && this.scenes.size === 0) {
	            this.threeRenderer.setAnimationLoop(null);
	        }
	    }
	    displayCanvas(scene) {
	        return scene.element.modelIsVisible && !this.multipleScenesVisible ? this.canvas3D : scene.element[$canvas];
	    }
	 countVisibleScenes() {
	        const { canvas3D } = this;
	        let visibleScenes = 0;
	        let canvas3DScene = null;
	        for (const scene of this.scenes){
	            const { element } = scene;
	            if (element.modelIsVisible && scene.externalRenderer == null) {
	                ++visibleScenes;
	            }
	            if (canvas3D.parentElement === scene.canvas.parentElement) {
	                canvas3DScene = scene;
	            }
	        }
	        const multipleScenesVisible = visibleScenes > 1;
	        if (canvas3DScene != null) {
	            const newlyMultiple = multipleScenesVisible && !this.multipleScenesVisible;
	            const disappearing = !canvas3DScene.element.modelIsVisible;
	            if (newlyMultiple || disappearing) {
	                const { width, height } = this.sceneSize(canvas3DScene);
	                this.copyPixels(canvas3DScene, width, height);
	                canvas3D.parentElement.removeChild(canvas3D);
	            }
	        }
	        this.multipleScenesVisible = multipleScenesVisible;
	    }
	 updateRendererSize() {
	        var _a;
	        const dpr = window.devicePixelRatio;
	        if (dpr !== this.dpr) {
	            for (const scene of this.scenes){
	                const { element } = scene;
	                element[$updateSize](element.getBoundingClientRect());
	            }
	        }
	        let width = 0;
	        let height = 0;
	        for (const scene of this.scenes){
	            width = Math.max(width, scene.width);
	            height = Math.max(height, scene.height);
	        }
	        if (width === this.width && height === this.height && dpr === this.dpr) {
	            return;
	        }
	        this.width = width;
	        this.height = height;
	        this.dpr = dpr;
	        width = Math.ceil(width * dpr);
	        height = Math.ceil(height * dpr);
	        if (this.canRender) {
	            this.threeRenderer.setSize(width, height, false);
	        }
	        for (const scene of this.scenes){
	            const { canvas } = scene;
	            canvas.width = width;
	            canvas.height = height;
	            scene.forceRescale();
	            (_a = scene.effectRenderer) === null || _a === void 0 ? void 0 : _a.setSize(width, height);
	        }
	    }
	    updateRendererScale(delta) {
	        const scaleStep = this.scaleStep;
	        this.avgFrameDuration += clamp(DURATION_DECAY * (delta - this.avgFrameDuration), -5, MAX_AVG_CHANGE_MS);
	        if (this.avgFrameDuration > HIGH_FRAME_DURATION_MS) {
	            ++this.scaleStep;
	        } else if (this.avgFrameDuration < LOW_FRAME_DURATION_MS && this.scaleStep > 0) {
	            --this.scaleStep;
	        }
	        this.scaleStep = Math.min(this.scaleStep, this.lastStep);
	        if (scaleStep !== this.scaleStep) {
	            this.avgFrameDuration = (HIGH_FRAME_DURATION_MS + LOW_FRAME_DURATION_MS) / 2;
	        }
	    }
	    shouldRender(scene) {
	        if (!scene.shouldRender()) {
	            if (scene.scaleStep != 0) {
	                scene.scaleStep = 0;
	                this.rescaleCanvas(scene);
	            } else {
	                return false;
	            }
	        } else if (scene.scaleStep != this.scaleStep) {
	            scene.scaleStep = this.scaleStep;
	            this.rescaleCanvas(scene);
	        }
	        return true;
	    }
	    rescaleCanvas(scene) {
	        const scale = SCALE_STEPS[scene.scaleStep];
	        const width = Math.ceil(this.width / scale);
	        const height = Math.ceil(this.height / scale);
	        const { style } = scene.canvas;
	        style.width = `${width}px`;
	        style.height = `${height}px`;
	        this.canvas3D.style.width = `${width}px`;
	        this.canvas3D.style.height = `${height}px`;
	        const renderedDpr = this.dpr * scale;
	        const reason = scale < 1 ? 'GPU throttling' : this.dpr !== window.devicePixelRatio ? 'No meta viewport tag' : '';
	        scene.element.dispatchEvent(new CustomEvent('render-scale', {
	            detail: {
	                reportedDpr: window.devicePixelRatio,
	                renderedDpr: renderedDpr,
	                minimumDpr: this.dpr * SCALE_STEPS[this.lastStep],
	                pixelWidth: Math.ceil(scene.width * renderedDpr),
	                pixelHeight: Math.ceil(scene.height * renderedDpr),
	                reason: reason
	            }
	        }));
	    }
	    sceneSize(scene) {
	        const { dpr } = this;
	        const scaleFactor = SCALE_STEPS[scene.scaleStep];
	        const width = Math.min(Math.ceil(scene.width * scaleFactor * dpr), this.canvas3D.width);
	        const height = Math.min(Math.ceil(scene.height * scaleFactor * dpr), this.canvas3D.height);
	        return {
	            width,
	            height
	        };
	    }
	    copyPixels(scene, width, height) {
	        const context2D = scene.context;
	        if (context2D == null) {
	            console.log('could not acquire 2d context');
	            return;
	        }
	        context2D.clearRect(0, 0, width, height);
	        context2D.drawImage(this.canvas3D, 0, 0, width, height, 0, 0, width, height);
	        scene.canvas.classList.add('show');
	    }
	 orderedScenes() {
	        const scenes = [];
	        for (const visible of [
	            false,
	            true
	        ]){
	            for (const scene of this.scenes){
	                if (scene.element.modelIsVisible === visible) {
	                    scenes.push(scene);
	                }
	            }
	        }
	        return scenes;
	    }
	    get isPresenting() {
	        return this.arRenderer.isPresenting;
	    }
	 preRender(scene, t, delta) {
	        const { element, exposure, toneMapping } = scene;
	        element[$tick](t, delta);
	        const exposureIsNumber = typeof exposure === 'number' && !Number.isNaN(exposure);
	        const env = element.environmentImage;
	        const sky = element.skyboxImage;
	        const compensateExposure = toneMapping === NeutralToneMapping && (env === 'neutral' || env === 'legacy' || !env && !sky);
	        this.threeRenderer.toneMappingExposure = (exposureIsNumber ? exposure : 1.0) * (compensateExposure ? COMMERCE_EXPOSURE : 1.0);
	    }
	    render(t, frame) {
	        if (frame != null) {
	            this.arRenderer.onWebXRFrame(t, frame);
	            return;
	        }
	        const delta = t - this.lastTick;
	        this.lastTick = t;
	        if (!this.canRender || this.isPresenting) {
	            return;
	        }
	        this.countVisibleScenes();
	        this.updateRendererSize();
	        if (this.renderedLastFrame) {
	            this.updateRendererScale(delta);
	            this.renderedLastFrame = false;
	        }
	        const { canvas3D } = this;
	        for (const scene of this.orderedScenes()){
	            const { element } = scene;
	            if (!element.loaded || !element.modelIsVisible && scene.renderCount > 0) {
	                continue;
	            }
	            this.preRender(scene, t, delta);
	            if (!this.shouldRender(scene)) {
	                continue;
	            }
	            if (scene.externalRenderer != null) {
	                const camera = scene.getCamera();
	                camera.updateMatrix();
	                const { matrix, projectionMatrix } = camera;
	                const viewMatrix = matrix.elements.slice();
	                const target = scene.getTarget();
	                viewMatrix[12] += target.x;
	                viewMatrix[13] += target.y;
	                viewMatrix[14] += target.z;
	                scene.externalRenderer.render({
	                    viewMatrix: viewMatrix,
	                    projectionMatrix: projectionMatrix.elements
	                });
	                continue;
	            }
	            if (!element.modelIsVisible && !this.multipleScenesVisible) {
	                for (const visibleScene of this.scenes){
	                    if (visibleScene.element.modelIsVisible) {
	                        visibleScene.queueRender();
	                    }
	                }
	            }
	            const { width, height } = this.sceneSize(scene);
	            scene.renderShadow(this.threeRenderer);
	            this.threeRenderer.setRenderTarget(null);
	            this.threeRenderer.setViewport(0, Math.ceil(this.height * this.dpr) - height, width, height);
	            if (scene.effectRenderer != null) {
	                scene.effectRenderer.render(delta);
	            } else {
	                this.threeRenderer.autoClear = true;
	                this.threeRenderer.toneMapping = scene.toneMapping;
	                this.threeRenderer.render(scene, scene.camera);
	            }
	            if (this.multipleScenesVisible || !scene.element.modelIsVisible && scene.renderCount === 0) {
	                this.copyPixels(scene, width, height);
	            } else if (canvas3D.parentElement !== scene.canvas.parentElement) {
	                scene.canvas.parentElement.appendChild(canvas3D);
	                scene.canvas.classList.remove('show');
	            }
	            scene.hasRendered();
	            ++scene.renderCount;
	            this.renderedLastFrame = true;
	        }
	    }
	    dispose() {
	        if (this.textureUtils != null) {
	            this.textureUtils.dispose();
	        }
	        if (this.threeRenderer != null) {
	            this.threeRenderer.dispose();
	        }
	        this.textureUtils = null;
	        this.threeRenderer = null;
	        const elements = [];
	        for (const scene of this.scenes){
	            elements.push(scene.element);
	        }
	        this.canvas3D.removeEventListener('webglcontextlost', this.onWebGLContextLost);
	        this.canvas3D.removeEventListener('webglcontextrestored', this.onWebGLContextRestored);
	        return elements;
	    }
	    constructor(options){
	        super();
	        this.loader = new CachingGLTFLoader(ModelViewerGLTFInstance);
	        this.width = 0;
	        this.height = 0;
	        this.dpr = 1;
	        this.scenes = new Set();
	        this.multipleScenesVisible = false;
	        this.lastTick = performance.now();
	        this.renderedLastFrame = false;
	        this.scaleStep = 0;
	        this.lastStep = DEFAULT_LAST_STEP;
	        this.avgFrameDuration = (HIGH_FRAME_DURATION_MS + LOW_FRAME_DURATION_MS) / 2;
	        this.onWebGLContextLost = (event)=>{
	            this.dispatchEvent({
	                type: 'contextlost',
	                sourceEvent: event
	            });
	        };
	        this.onWebGLContextRestored = ()=>{
	            var _a;
	            (_a = this.textureUtils) === null || _a === void 0 ? void 0 : _a.dispose();
	            this.textureUtils = new TextureUtils(this.threeRenderer);
	            for (const scene of this.scenes){
	                scene.element[$updateEnvironment]();
	            }
	        };
	        this.dpr = window.devicePixelRatio;
	        this.canvas3D = document.createElement('canvas');
	        this.canvas3D.id = 'webgl-canvas';
	        this.canvas3D.classList.add('show');
	        try {
	            this.threeRenderer = new WebGLRenderer({
	                canvas: this.canvas3D,
	                alpha: true,
	                antialias: true,
	                powerPreference: options.powerPreference,
	                preserveDrawingBuffer: true
	            });
	            this.threeRenderer.autoClear = true;
	            this.threeRenderer.setPixelRatio(1);
	            this.threeRenderer.debug = {
	                checkShaderErrors: !!options.debug,
	                onShaderError: null
	            };
	            this.threeRenderer.toneMapping = NeutralToneMapping;
	        } catch (error) {
	            console.warn(error);
	        }
	        this.arRenderer = new ARRenderer(this);
	        this.textureUtils = this.canRender ? new TextureUtils(this.threeRenderer) : null;
	        CachingGLTFLoader.initializeKTX2Loader(this.threeRenderer);
	        this.canvas3D.addEventListener('webglcontextlost', this.onWebGLContextLost);
	        this.canvas3D.addEventListener('webglcontextrestored', this.onWebGLContextRestored);
	        this.updateRendererSize();
	    }
	}

	const $correlatedObjects = Symbol('correlatedObjects');
	const $onUpdate$1 = Symbol('onUpdate');
	 class ThreeDOMElement {
	    constructor(onUpdate, correlatedObjects){
	        this[$onUpdate$1] = onUpdate;
	        this[$correlatedObjects] = correlatedObjects;
	    }
	}

	const quadMaterial = new MeshBasicMaterial();
	const quad = new PlaneGeometry(2, 2);
	let adhocNum = 0;
	const $threeTexture$2 = Symbol('threeTexture');
	const $threeTextures$1 = Symbol('threeTextures');
	 let Image$1 = class Image extends ThreeDOMElement {
	    get [$threeTexture$2]() {
	        var _a;
	        return (_a = this[$correlatedObjects]) === null || _a === void 0 ? void 0 : _a.values().next().value;
	    }
	    get [$threeTextures$1]() {
	        return this[$correlatedObjects];
	    }
	    get name() {
	        return this[$threeTexture$2].image.name || '';
	    }
	    get uri() {
	        return this[$threeTexture$2].image.src;
	    }
	    get bufferView() {
	        return this[$threeTexture$2].image.bufferView;
	    }
	    get element() {
	        const texture = this[$threeTexture$2];
	        if (texture && (texture.isCanvasTexture || texture.isVideoTexture)) {
	            return texture.image;
	        }
	        return;
	    }
	    get animation() {
	        const texture = this[$threeTexture$2];
	        if (texture && texture.isCanvasTexture && texture.animation) {
	            return texture.animation;
	        }
	        return;
	    }
	    get type() {
	        return this.uri != null ? 'external' : 'embedded';
	    }
	    set name(name) {
	        for (const texture of this[$threeTextures$1]){
	            texture.image.name = name;
	        }
	    }
	    update() {
	        const texture = this[$threeTexture$2];
	        if (texture && texture.isCanvasTexture && !texture.animation) {
	            this[$threeTexture$2].needsUpdate = true;
	            this[$onUpdate$1]();
	        }
	    }
	    async createThumbnail(width, height) {
	        const scene = new Scene();
	        quadMaterial.map = this[$threeTexture$2];
	        const mesh = new Mesh(quad, quadMaterial);
	        scene.add(mesh);
	        const camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
	        const { threeRenderer } = Renderer.singleton;
	        const renderTarget = new WebGLRenderTarget(width, height);
	        threeRenderer.setRenderTarget(renderTarget);
	        threeRenderer.render(scene, camera);
	        threeRenderer.setRenderTarget(null);
	        const buffer = new Uint8Array(width * height * 4);
	        threeRenderer.readRenderTargetPixels(renderTarget, 0, 0, width, height, buffer);
	        blobCanvas.width = width;
	        blobCanvas.height = height;
	        const blobContext = blobCanvas.getContext('2d');
	        const imageData = blobContext.createImageData(width, height);
	        imageData.data.set(buffer);
	        blobContext.putImageData(imageData, 0, 0);
	        return new Promise(async (resolve, reject)=>{
	            blobCanvas.toBlob((blob)=>{
	                if (!blob) {
	                    return reject('Failed to capture thumbnail.');
	                }
	                resolve(URL.createObjectURL(blob));
	            }, 'image/png');
	        });
	    }
	    constructor(onUpdate, texture){
	        super(onUpdate, new Set(texture ? [
	            texture
	        ] : []));
	        if (!this[$threeTexture$2].image.src) {
	            this[$threeTexture$2].image.src = texture.name ? texture.name : 'adhoc_image' + adhocNum++;
	        }
	        if (!this[$threeTexture$2].image.name) {
	            this[$threeTexture$2].image.name = texture && texture.image && texture.image.src ? texture.image.src.split('/').pop() : 'adhoc_image';
	        }
	    }
	};

	var Filter;
	(function(Filter) {
	    Filter[Filter["Nearest"] = 9728] = "Nearest";
	    Filter[Filter["Linear"] = 9729] = "Linear";
	    Filter[Filter["NearestMipmapNearest"] = 9984] = "NearestMipmapNearest";
	    Filter[Filter["LinearMipmapNearest"] = 9985] = "LinearMipmapNearest";
	    Filter[Filter["NearestMipmapLinear"] = 9986] = "NearestMipmapLinear";
	    Filter[Filter["LinearMipmapLinear"] = 9987] = "LinearMipmapLinear";
	})(Filter || (Filter = {}));
	var Wrap;
	(function(Wrap) {
	    Wrap[Wrap["ClampToEdge"] = 33071] = "ClampToEdge";
	    Wrap[Wrap["MirroredRepeat"] = 33648] = "MirroredRepeat";
	    Wrap[Wrap["Repeat"] = 10497] = "Repeat";
	})(Wrap || (Wrap = {}));

	const wrapModeToWrapping = new Map([
	    [
	        Wrap.Repeat,
	        RepeatWrapping
	    ],
	    [
	        Wrap.ClampToEdge,
	        ClampToEdgeWrapping
	    ],
	    [
	        Wrap.MirroredRepeat,
	        MirroredRepeatWrapping
	    ]
	]);
	const wrappingToWrapMode = new Map([
	    [
	        RepeatWrapping,
	        Wrap.Repeat
	    ],
	    [
	        ClampToEdgeWrapping,
	        Wrap.ClampToEdge
	    ],
	    [
	        MirroredRepeatWrapping,
	        Wrap.MirroredRepeat
	    ]
	]);
	const minFilterToMinification = new Map([
	    [
	        Filter.Nearest,
	        NearestFilter
	    ],
	    [
	        Filter.Linear,
	        LinearFilter
	    ],
	    [
	        Filter.NearestMipmapNearest,
	        NearestMipmapNearestFilter
	    ],
	    [
	        Filter.LinearMipmapNearest,
	        LinearMipmapNearestFilter
	    ],
	    [
	        Filter.NearestMipmapLinear,
	        NearestMipmapLinearFilter
	    ],
	    [
	        Filter.LinearMipmapLinear,
	        LinearMipmapLinearFilter
	    ]
	]);
	const minificationToMinFilter = new Map([
	    [
	        NearestFilter,
	        Filter.Nearest
	    ],
	    [
	        LinearFilter,
	        Filter.Linear
	    ],
	    [
	        NearestMipmapNearestFilter,
	        Filter.NearestMipmapNearest
	    ],
	    [
	        LinearMipmapNearestFilter,
	        Filter.LinearMipmapNearest
	    ],
	    [
	        NearestMipmapLinearFilter,
	        Filter.NearestMipmapLinear
	    ],
	    [
	        LinearMipmapLinearFilter,
	        Filter.LinearMipmapLinear
	    ]
	]);
	const magFilterToMagnification = new Map([
	    [
	        Filter.Nearest,
	        NearestFilter
	    ],
	    [
	        Filter.Linear,
	        LinearFilter
	    ]
	]);
	const magnificationToMagFilter = new Map([
	    [
	        NearestFilter,
	        Filter.Nearest
	    ],
	    [
	        LinearFilter,
	        Filter.Linear
	    ]
	]);
	const isMinFilter = (()=>{
	    return (value)=>minificationToMinFilter.has(value);
	})();
	const isMagFilter = (()=>{
	    return (value)=>magnificationToMagFilter.has(value);
	})();
	const isWrapping = (()=>{
	    return (value)=>wrappingToWrapMode.has(value);
	})();
	const isValidSamplerValue = (property, value)=>{
	    switch(property){
	        case 'minFilter':
	            return isMinFilter(value);
	        case 'magFilter':
	            return isMagFilter(value);
	        case 'wrapS':
	        case 'wrapT':
	            return isWrapping(value);
	        case 'rotation':
	        case 'repeat':
	        case 'offset':
	            return true;
	        default:
	            throw new Error(`Cannot configure property "${property}" on Sampler`);
	    }
	};
	const $threeTexture$1 = Symbol('threeTexture');
	const $threeTextures = Symbol('threeTextures');
	const $setProperty = Symbol('setProperty');
	 class Sampler extends ThreeDOMElement {
	    get [$threeTexture$1]() {
	        var _a;
	        return (_a = this[$correlatedObjects]) === null || _a === void 0 ? void 0 : _a.values().next().value;
	    }
	    get [$threeTextures]() {
	        return this[$correlatedObjects];
	    }
	    get name() {
	        return this[$threeTexture$1].name || '';
	    }
	    get minFilter() {
	        return minificationToMinFilter.get(this[$threeTexture$1].minFilter);
	    }
	    get magFilter() {
	        return magnificationToMagFilter.get(this[$threeTexture$1].magFilter);
	    }
	    get wrapS() {
	        return wrappingToWrapMode.get(this[$threeTexture$1].wrapS);
	    }
	    get wrapT() {
	        return wrappingToWrapMode.get(this[$threeTexture$1].wrapT);
	    }
	    get rotation() {
	        return this[$threeTexture$1].rotation;
	    }
	    get scale() {
	        return toVector2D(this[$threeTexture$1].repeat);
	    }
	    get offset() {
	        return toVector2D(this[$threeTexture$1].offset);
	    }
	    setMinFilter(filter) {
	        this[$setProperty]('minFilter', minFilterToMinification.get(filter));
	    }
	    setMagFilter(filter) {
	        this[$setProperty]('magFilter', magFilterToMagnification.get(filter));
	    }
	    setWrapS(mode) {
	        this[$setProperty]('wrapS', wrapModeToWrapping.get(mode));
	    }
	    setWrapT(mode) {
	        this[$setProperty]('wrapT', wrapModeToWrapping.get(mode));
	    }
	    setRotation(rotation) {
	        if (rotation == null) {
	            rotation = 0;
	        }
	        this[$setProperty]('rotation', rotation);
	    }
	    setScale(scale) {
	        if (scale == null) {
	            scale = {
	                u: 1,
	                v: 1
	            };
	        }
	        this[$setProperty]('repeat', new Vector2(scale.u, scale.v));
	    }
	    setOffset(offset) {
	        if (offset == null) {
	            offset = {
	                u: 0,
	                v: 0
	            };
	        }
	        this[$setProperty]('offset', new Vector2(offset.u, offset.v));
	    }
	    [$setProperty](property, value) {
	        if (isValidSamplerValue(property, value)) {
	            for (const texture of this[$threeTextures]){
	                texture[property] = value;
	                texture.needsUpdate = true;
	            }
	        }
	        this[$onUpdate$1]();
	    }
	    constructor(onUpdate, texture){
	        super(onUpdate, new Set(texture ? [
	            texture
	        ] : []));
	    }
	}

	const $image = Symbol('image');
	const $sampler = Symbol('sampler');
	const $threeTexture = Symbol('threeTexture');
	 class Texture extends ThreeDOMElement {
	    get [$threeTexture]() {
	        var _a;
	        return (_a = this[$correlatedObjects]) === null || _a === void 0 ? void 0 : _a.values().next().value;
	    }
	    get name() {
	        return this[$threeTexture].name || '';
	    }
	    set name(name) {
	        for (const texture of this[$correlatedObjects]){
	            texture.name = name;
	        }
	    }
	    get sampler() {
	        return this[$sampler];
	    }
	    get source() {
	        return this[$image];
	    }
	    constructor(onUpdate, threeTexture){
	        super(onUpdate, new Set(threeTexture ? [
	            threeTexture
	        ] : []));
	        this[$sampler] = new Sampler(onUpdate, threeTexture);
	        this[$image] = new Image$1(onUpdate, threeTexture);
	    }
	}

	var _a$4, _b$4, _c$2;
	const $texture = Symbol('texture');
	const $transform = Symbol('transform');
	const $materials$1 = Symbol('materials');
	const $usage = Symbol('usage');
	const $onUpdate = Symbol('onUpdate');
	const $activeVideo = Symbol('activeVideo');
	var TextureUsage;
	(function(TextureUsage) {
	    TextureUsage[TextureUsage["Base"] = 0] = "Base";
	    TextureUsage[TextureUsage["MetallicRoughness"] = 1] = "MetallicRoughness";
	    TextureUsage[TextureUsage["Normal"] = 2] = "Normal";
	    TextureUsage[TextureUsage["Occlusion"] = 3] = "Occlusion";
	    TextureUsage[TextureUsage["Emissive"] = 4] = "Emissive";
	    TextureUsage[TextureUsage["Clearcoat"] = 5] = "Clearcoat";
	    TextureUsage[TextureUsage["ClearcoatRoughness"] = 6] = "ClearcoatRoughness";
	    TextureUsage[TextureUsage["ClearcoatNormal"] = 7] = "ClearcoatNormal";
	    TextureUsage[TextureUsage["SheenColor"] = 8] = "SheenColor";
	    TextureUsage[TextureUsage["SheenRoughness"] = 9] = "SheenRoughness";
	    TextureUsage[TextureUsage["Transmission"] = 10] = "Transmission";
	    TextureUsage[TextureUsage["Thickness"] = 11] = "Thickness";
	    TextureUsage[TextureUsage["Specular"] = 12] = "Specular";
	    TextureUsage[TextureUsage["SpecularColor"] = 13] = "SpecularColor";
	    TextureUsage[TextureUsage["Iridescence"] = 14] = "Iridescence";
	    TextureUsage[TextureUsage["IridescenceThickness"] = 15] = "IridescenceThickness";
	    TextureUsage[TextureUsage["Anisotropy"] = 16] = "Anisotropy";
	})(TextureUsage || (TextureUsage = {}));
	 class TextureInfo {
	    get texture() {
	        return this[$texture];
	    }
	    setTexture(texture) {
	        var _d, _e;
	        const threeTexture = texture != null ? texture.source[$threeTexture$2] : null;
	        const oldTexture = (_d = this[$texture]) === null || _d === void 0 ? void 0 : _d.source[$threeTexture$2];
	        if (oldTexture != null && oldTexture.isVideoTexture) {
	            this[$activeVideo] = false;
	        } else if ((_e = this[$texture]) === null || _e === void 0 ? void 0 : _e.source.animation) {
	            this[$texture].source.animation.removeEventListener('enterFrame', this[$onUpdate]);
	        }
	        this[$texture] = texture;
	        if (threeTexture != null && threeTexture.isVideoTexture) {
	            const element = threeTexture.image;
	            this[$activeVideo] = true;
	            if (element.requestVideoFrameCallback != null) {
	                const update = ()=>{
	                    if (!this[$activeVideo]) {
	                        return;
	                    }
	                    this[$onUpdate]();
	                    element.requestVideoFrameCallback(update);
	                };
	                element.requestVideoFrameCallback(update);
	            } else {
	                const update = ()=>{
	                    if (!this[$activeVideo]) {
	                        return;
	                    }
	                    this[$onUpdate]();
	                    requestAnimationFrame(update);
	                };
	                requestAnimationFrame(update);
	            }
	        } else if ((texture === null || texture === void 0 ? void 0 : texture.source.animation) != null) {
	            texture.source.animation.addEventListener('enterFrame', this[$onUpdate]);
	        }
	        let colorSpace = SRGBColorSpace;
	        if (this[$materials$1]) {
	            for (const material of this[$materials$1]){
	                switch(this[$usage]){
	                    case TextureUsage.Base:
	                        material.map = threeTexture;
	                        break;
	                    case TextureUsage.MetallicRoughness:
	                        colorSpace = LinearSRGBColorSpace;
	                        material.metalnessMap = threeTexture;
	                        material.roughnessMap = threeTexture;
	                        break;
	                    case TextureUsage.Normal:
	                        colorSpace = LinearSRGBColorSpace;
	                        material.normalMap = threeTexture;
	                        break;
	                    case TextureUsage.Occlusion:
	                        colorSpace = LinearSRGBColorSpace;
	                        material.aoMap = threeTexture;
	                        break;
	                    case TextureUsage.Emissive:
	                        material.emissiveMap = threeTexture;
	                        break;
	                    case TextureUsage.Clearcoat:
	                        material.clearcoatMap = threeTexture;
	                        break;
	                    case TextureUsage.ClearcoatRoughness:
	                        material.clearcoatRoughnessMap = threeTexture;
	                        break;
	                    case TextureUsage.ClearcoatNormal:
	                        material.clearcoatNormalMap = threeTexture;
	                        break;
	                    case TextureUsage.SheenColor:
	                        material.sheenColorMap = threeTexture;
	                        break;
	                    case TextureUsage.SheenRoughness:
	                        material.sheenRoughnessMap = threeTexture;
	                        break;
	                    case TextureUsage.Transmission:
	                        material.transmissionMap = threeTexture;
	                        break;
	                    case TextureUsage.Thickness:
	                        material.thicknessMap = threeTexture;
	                        break;
	                    case TextureUsage.Specular:
	                        material.specularIntensityMap = threeTexture;
	                        break;
	                    case TextureUsage.SpecularColor:
	                        material.specularColorMap = threeTexture;
	                        break;
	                    case TextureUsage.Iridescence:
	                        material.iridescenceMap = threeTexture;
	                        break;
	                    case TextureUsage.IridescenceThickness:
	                        material.iridescenceThicknessMap = threeTexture;
	                        break;
	                    case TextureUsage.Anisotropy:
	                        material.anisotropyMap = threeTexture;
	                        break;
	                }
	                material.needsUpdate = true;
	            }
	        }
	        if (threeTexture) {
	            threeTexture.colorSpace = colorSpace;
	            threeTexture.rotation = this[$transform].rotation;
	            threeTexture.repeat = this[$transform].scale;
	            threeTexture.offset = this[$transform].offset;
	        }
	        this[$onUpdate]();
	    }
	    constructor(onUpdate, usage, threeTexture, material){
	        this[_a$4] = null;
	        this[_b$4] = {
	            rotation: 0,
	            scale: new Vector2(1, 1),
	            offset: new Vector2(0, 0)
	        };
	        this[_c$2] = false;
	        if (threeTexture) {
	            this[$transform].rotation = threeTexture.rotation;
	            this[$transform].scale.copy(threeTexture.repeat);
	            this[$transform].offset.copy(threeTexture.offset);
	            this[$texture] = new Texture(onUpdate, threeTexture);
	        }
	        this[$onUpdate] = onUpdate;
	        this[$materials$1] = material;
	        this[$usage] = usage;
	    }
	}
	_a$4 = $texture, _b$4 = $transform, _c$2 = $activeVideo;

	const $threeMaterial = Symbol('threeMaterial');
	const $threeMaterials = Symbol('threeMaterials');
	const $baseColorTexture = Symbol('baseColorTexture');
	const $metallicRoughnessTexture = Symbol('metallicRoughnessTexture');
	 class PBRMetallicRoughness extends ThreeDOMElement {
	    get [$threeMaterials]() {
	        return this[$correlatedObjects];
	    }
	    get [$threeMaterial]() {
	        var _a;
	        return (_a = this[$correlatedObjects]) === null || _a === void 0 ? void 0 : _a.values().next().value;
	    }
	    get baseColorFactor() {
	        const rgba = [
	            0,
	            0,
	            0,
	            this[$threeMaterial].opacity
	        ];
	        this[$threeMaterial].color.toArray(rgba);
	        return rgba;
	    }
	    get metallicFactor() {
	        return this[$threeMaterial].metalness;
	    }
	    get roughnessFactor() {
	        return this[$threeMaterial].roughness;
	    }
	    get baseColorTexture() {
	        return this[$baseColorTexture];
	    }
	    get metallicRoughnessTexture() {
	        return this[$metallicRoughnessTexture];
	    }
	    setBaseColorFactor(rgba) {
	        const color = new Color();
	        if (rgba instanceof Array) {
	            color.fromArray(rgba);
	        } else {
	            color.set(rgba);
	        }
	        for (const material of this[$threeMaterials]){
	            material.color.set(color);
	            if (rgba instanceof Array && rgba.length > 3) {
	                material.opacity = rgba[3];
	            } else {
	                rgba = [
	                    0,
	                    0,
	                    0,
	                    material.opacity
	                ];
	                color.toArray(rgba);
	            }
	        }
	        this[$onUpdate$1]();
	    }
	    setMetallicFactor(value) {
	        for (const material of this[$threeMaterials]){
	            material.metalness = value;
	        }
	        this[$onUpdate$1]();
	    }
	    setRoughnessFactor(value) {
	        for (const material of this[$threeMaterials]){
	            material.roughness = value;
	        }
	        this[$onUpdate$1]();
	    }
	    constructor(onUpdate, correlatedMaterials){
	        super(onUpdate, correlatedMaterials);
	        const { map, metalnessMap } = correlatedMaterials.values().next().value;
	        this[$baseColorTexture] = new TextureInfo(onUpdate, TextureUsage.Base, map, correlatedMaterials);
	        this[$metallicRoughnessTexture] = new TextureInfo(onUpdate, TextureUsage.MetallicRoughness, metalnessMap, correlatedMaterials);
	    }
	}

	var _a$3, _b$3;
	const $pbrMetallicRoughness = Symbol('pbrMetallicRoughness');
	const $normalTexture = Symbol('normalTexture');
	const $occlusionTexture = Symbol('occlusionTexture');
	const $emissiveTexture = Symbol('emissiveTexture');
	const $backingThreeMaterial = Symbol('backingThreeMaterial');
	const $applyAlphaCutoff = Symbol('applyAlphaCutoff');
	const $getAlphaMode = Symbol('getAlphaMode');
	const $lazyLoadGLTFInfo = Symbol('lazyLoadGLTFInfo');
	const $initialize = Symbol('initialize');
	const $getLoadedMaterial = Symbol('getLoadedMaterial');
	const $ensureMaterialIsLoaded = Symbol('ensureMaterialIsLoaded');
	const $gltfIndex = Symbol('gltfIndex');
	const $setActive = Symbol('setActive');
	const $variantIndices = Symbol('variantIndices');
	const $isActive = Symbol('isActive');
	const $modelVariants = Symbol('modelVariants');
	const $name = Symbol('name');
	const $pbrTextures = Symbol('pbrTextures');
	 class Material extends ThreeDOMElement {
	    get [(_a$3 = $variantIndices, _b$3 = $pbrTextures, $backingThreeMaterial)]() {
	        return this[$correlatedObjects].values().next().value;
	    }
	    [$initialize]() {
	        const onUpdate = this[$onUpdate$1];
	        const correlatedMaterials = this[$correlatedObjects];
	        this[$pbrMetallicRoughness] = new PBRMetallicRoughness(onUpdate, correlatedMaterials);
	        const { normalMap, aoMap, emissiveMap } = correlatedMaterials.values().next().value;
	        this[$normalTexture] = new TextureInfo(onUpdate, TextureUsage.Normal, normalMap, correlatedMaterials);
	        this[$occlusionTexture] = new TextureInfo(onUpdate, TextureUsage.Occlusion, aoMap, correlatedMaterials);
	        this[$emissiveTexture] = new TextureInfo(onUpdate, TextureUsage.Emissive, emissiveMap, correlatedMaterials);
	        const createTextureInfo = (usage)=>{
	            this[$pbrTextures].set(usage, new TextureInfo(onUpdate, usage, null, correlatedMaterials));
	        };
	        createTextureInfo(TextureUsage.Clearcoat);
	        createTextureInfo(TextureUsage.ClearcoatRoughness);
	        createTextureInfo(TextureUsage.ClearcoatNormal);
	        createTextureInfo(TextureUsage.SheenColor);
	        createTextureInfo(TextureUsage.SheenRoughness);
	        createTextureInfo(TextureUsage.Transmission);
	        createTextureInfo(TextureUsage.Thickness);
	        createTextureInfo(TextureUsage.Specular);
	        createTextureInfo(TextureUsage.SpecularColor);
	        createTextureInfo(TextureUsage.Iridescence);
	        createTextureInfo(TextureUsage.IridescenceThickness);
	        createTextureInfo(TextureUsage.Anisotropy);
	    }
	    async [$getLoadedMaterial]() {
	        if (this[$lazyLoadGLTFInfo] != null) {
	            const material = await this[$lazyLoadGLTFInfo].doLazyLoad();
	            this[$initialize]();
	            this[$lazyLoadGLTFInfo] = undefined;
	            this.ensureLoaded = async ()=>{};
	            return material;
	        }
	        return null;
	    }
	    colorFromRgb(rgb) {
	        const color = new Color();
	        if (rgb instanceof Array) {
	            color.fromArray(rgb);
	        } else {
	            color.set(rgb);
	        }
	        return color;
	    }
	    [$ensureMaterialIsLoaded]() {
	        if (this[$lazyLoadGLTFInfo] == null) {
	            return;
	        }
	        throw new Error(`Material "${this.name}" has not been loaded, call 'await
    myMaterial.ensureLoaded()' before using an unloaded material.`);
	    }
	    async ensureLoaded() {
	        await this[$getLoadedMaterial]();
	    }
	    get isLoaded() {
	        return this[$lazyLoadGLTFInfo] == null;
	    }
	    get isActive() {
	        return this[$isActive];
	    }
	    [$setActive](isActive) {
	        this[$isActive] = isActive;
	    }
	    get name() {
	        return this[$name] || '';
	    }
	    set name(name) {
	        this[$name] = name;
	        if (this[$correlatedObjects] != null) {
	            for (const threeMaterial of this[$correlatedObjects]){
	                threeMaterial.name = name;
	            }
	        }
	    }
	    get pbrMetallicRoughness() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrMetallicRoughness];
	    }
	    get normalTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$normalTexture];
	    }
	    get occlusionTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$occlusionTexture];
	    }
	    get emissiveTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$emissiveTexture];
	    }
	    get emissiveFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].emissive.toArray();
	    }
	    get index() {
	        return this[$gltfIndex];
	    }
	    hasVariant(name) {
	        const variantData = this[$modelVariants].get(name);
	        return variantData != null && this[$variantIndices].has(variantData.index);
	    }
	    setEmissiveFactor(rgb) {
	        this[$ensureMaterialIsLoaded]();
	        const color = this.colorFromRgb(rgb);
	        for (const material of this[$correlatedObjects]){
	            material.emissive.set(color);
	        }
	        this[$onUpdate$1]();
	    }
	    [$getAlphaMode]() {
	        if (this[$backingThreeMaterial].transparent) {
	            return 'BLEND';
	        } else {
	            if (this[$backingThreeMaterial].alphaTest > 0.0) {
	                return 'MASK';
	            }
	        }
	        return 'OPAQUE';
	    }
	    [$applyAlphaCutoff]() {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            if (this[$getAlphaMode]() === 'MASK') {
	                if (material.alphaTest == undefined) {
	                    material.alphaTest = 0.5;
	                }
	            } else {
	                material.alphaTest = undefined;
	            }
	            material.needsUpdate = true;
	        }
	    }
	    setAlphaCutoff(cutoff) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.alphaTest = cutoff;
	            material.needsUpdate = true;
	        }
	        this[$applyAlphaCutoff]();
	        this[$onUpdate$1]();
	    }
	    getAlphaCutoff() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].alphaTest;
	    }
	    setDoubleSided(doubleSided) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.side = doubleSided ? DoubleSide : FrontSide;
	            material.needsUpdate = true;
	        }
	        this[$onUpdate$1]();
	    }
	    getDoubleSided() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].side == DoubleSide;
	    }
	    setAlphaMode(alphaMode) {
	        this[$ensureMaterialIsLoaded]();
	        const enableTransparency = (material, enabled)=>{
	            material.transparent = enabled;
	            material.depthWrite = !enabled;
	        };
	        for (const material of this[$correlatedObjects]){
	            enableTransparency(material, alphaMode === 'BLEND');
	            if (alphaMode === 'MASK') {
	                material.alphaTest = 0.5;
	            } else {
	                material.alphaTest = undefined;
	            }
	            material.needsUpdate = true;
	        }
	        this[$onUpdate$1]();
	    }
	    getAlphaMode() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$getAlphaMode]();
	    }
	    get emissiveStrength() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].emissiveIntensity;
	    }
	    setEmissiveStrength(emissiveStrength) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.emissiveIntensity = emissiveStrength;
	        }
	        this[$onUpdate$1]();
	    }
	    get clearcoatFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].clearcoat;
	    }
	    get clearcoatRoughnessFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].clearcoatRoughness;
	    }
	    get clearcoatTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.Clearcoat);
	    }
	    get clearcoatRoughnessTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.ClearcoatRoughness);
	    }
	    get clearcoatNormalTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.ClearcoatNormal);
	    }
	    get clearcoatNormalScale() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].clearcoatNormalScale.x;
	    }
	    setClearcoatFactor(clearcoatFactor) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.clearcoat = clearcoatFactor;
	        }
	        this[$onUpdate$1]();
	    }
	    setClearcoatRoughnessFactor(clearcoatRoughnessFactor) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.clearcoatRoughness = clearcoatRoughnessFactor;
	        }
	        this[$onUpdate$1]();
	    }
	    setClearcoatNormalScale(clearcoatNormalScale) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.clearcoatNormalScale = new Vector2(clearcoatNormalScale, clearcoatNormalScale);
	        }
	        this[$onUpdate$1]();
	    }
	    get ior() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].ior;
	    }
	    setIor(ior) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.ior = ior;
	        }
	        this[$onUpdate$1]();
	    }
	    get sheenColorFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].sheenColor.toArray();
	    }
	    get sheenColorTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.SheenColor);
	    }
	    get sheenRoughnessFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].sheenRoughness;
	    }
	    get sheenRoughnessTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.SheenRoughness);
	    }
	    setSheenColorFactor(rgb) {
	        this[$ensureMaterialIsLoaded]();
	        const color = this.colorFromRgb(rgb);
	        for (const material of this[$correlatedObjects]){
	            material.sheenColor.set(color);
	            material.sheen = 1;
	        }
	        this[$onUpdate$1]();
	    }
	    setSheenRoughnessFactor(roughness) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.sheenRoughness = roughness;
	            material.sheen = 1;
	        }
	        this[$onUpdate$1]();
	    }
	    get transmissionFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].transmission;
	    }
	    get transmissionTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.Transmission);
	    }
	    setTransmissionFactor(transmission) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.transmission = transmission;
	        }
	        this[$onUpdate$1]();
	    }
	    get thicknessFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].thickness;
	    }
	    get thicknessTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.Thickness);
	    }
	    get attenuationDistance() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].attenuationDistance;
	    }
	    get attenuationColor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].attenuationColor.toArray();
	    }
	    setThicknessFactor(thickness) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.thickness = thickness;
	        }
	        this[$onUpdate$1]();
	    }
	    setAttenuationDistance(attenuationDistance) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.attenuationDistance = attenuationDistance;
	        }
	        this[$onUpdate$1]();
	    }
	    setAttenuationColor(rgb) {
	        this[$ensureMaterialIsLoaded]();
	        const color = this.colorFromRgb(rgb);
	        for (const material of this[$correlatedObjects]){
	            material.attenuationColor.set(color);
	        }
	        this[$onUpdate$1]();
	    }
	    get specularFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].specularIntensity;
	    }
	    get specularTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.Specular);
	    }
	    get specularColorFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].specularColor.toArray();
	    }
	    get specularColorTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.SheenColor);
	    }
	    setSpecularFactor(specularFactor) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.specularIntensity = specularFactor;
	        }
	        this[$onUpdate$1]();
	    }
	    setSpecularColorFactor(rgb) {
	        this[$ensureMaterialIsLoaded]();
	        const color = this.colorFromRgb(rgb);
	        for (const material of this[$correlatedObjects]){
	            material.specularColor.set(color);
	        }
	        this[$onUpdate$1]();
	    }
	    get iridescenceFactor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].iridescence;
	    }
	    get iridescenceTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.Iridescence);
	    }
	    get iridescenceIor() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].iridescenceIOR;
	    }
	    get iridescenceThicknessMinimum() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].iridescenceThicknessRange[0];
	    }
	    get iridescenceThicknessMaximum() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].iridescenceThicknessRange[1];
	    }
	    get iridescenceThicknessTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.IridescenceThickness);
	    }
	    setIridescenceFactor(iridescence) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.iridescence = iridescence;
	        }
	        this[$onUpdate$1]();
	    }
	    setIridescenceIor(ior) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.iridescenceIOR = ior;
	        }
	        this[$onUpdate$1]();
	    }
	    setIridescenceThicknessMinimum(thicknessMin) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.iridescenceThicknessRange[0] = thicknessMin;
	        }
	        this[$onUpdate$1]();
	    }
	    setIridescenceThicknessMaximum(thicknessMax) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.iridescenceThicknessRange[1] = thicknessMax;
	        }
	        this[$onUpdate$1]();
	    }
	    get anisotropyStrength() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].anisotropy;
	    }
	    get anisotropyRotation() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$backingThreeMaterial].anisotropyRotation;
	    }
	    get anisotropyTexture() {
	        this[$ensureMaterialIsLoaded]();
	        return this[$pbrTextures].get(TextureUsage.Anisotropy);
	    }
	    setAnisotropyStrength(strength) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.anisotropy = strength;
	        }
	        this[$onUpdate$1]();
	    }
	    setAnisotropyRotation(rotation) {
	        this[$ensureMaterialIsLoaded]();
	        for (const material of this[$correlatedObjects]){
	            material.anisotropyRotation = rotation;
	        }
	        this[$onUpdate$1]();
	    }
	    constructor(onUpdate, gltfIndex, isActive, modelVariants, correlatedMaterials, name, lazyLoadInfo = undefined){
	        super(onUpdate, correlatedMaterials);
	        this[_a$3] = new Set();
	        this[_b$3] = new Map();
	        this[$gltfIndex] = gltfIndex;
	        this[$isActive] = isActive;
	        this[$modelVariants] = modelVariants;
	        this[$name] = name;
	        if (lazyLoadInfo == null) {
	            this[$initialize]();
	        } else {
	            this[$lazyLoadGLTFInfo] = lazyLoadInfo;
	        }
	    }
	}

	let Node$1 = class Node {
	    constructor(name){
	        this.name = '';
	        this.children = new Array();
	        this.name = name;
	    }
	};
	class PrimitiveNode extends Node$1 {
	    async setActiveMaterial(material) {
	        const mvMaterial = this.materials.get(material);
	        if (material !== this.activeMaterialIdx) {
	            const backingMaterials = mvMaterial[$correlatedObjects];
	            const baseMaterial = await mvMaterial[$getLoadedMaterial]();
	            if (baseMaterial != null) {
	                this.mesh.material = baseMaterial;
	            } else {
	                this.mesh.material = backingMaterials.values().next().value;
	            }
	            this.parser.assignFinalMaterial(this.mesh);
	            backingMaterials.add(this.mesh.material);
	            this.activeMaterialIdx = material;
	        }
	        return this.mesh.material;
	    }
	    getActiveMaterial() {
	        return this.materials.get(this.activeMaterialIdx);
	    }
	    getMaterial(index) {
	        return this.materials.get(index);
	    }
	    async enableVariant(name) {
	        if (name == null) {
	            return this.setActiveMaterial(this.initialMaterialIdx);
	        }
	        if (this.variantToMaterialMap != null && this.modelVariants.has(name)) {
	            const modelVariants = this.modelVariants.get(name);
	            return this.enableVariantHelper(modelVariants.index);
	        }
	        return null;
	    }
	    async enableVariantHelper(index) {
	        if (this.variantToMaterialMap != null && index != null) {
	            const material = this.variantToMaterialMap.get(index);
	            if (material != null) {
	                return this.setActiveMaterial(material.index);
	            }
	        }
	        return null;
	    }
	    async instantiateVariants() {
	        if (this.variantToMaterialMap == null) {
	            return;
	        }
	        for (const index of this.variantToMaterialMap.keys()){
	            const variantMaterial = this.mesh.userData.variantMaterials.get(index);
	            if (variantMaterial.material != null) {
	                continue;
	            }
	            const threeMaterial = await this.enableVariantHelper(index);
	            if (threeMaterial != null) {
	                variantMaterial.material = threeMaterial;
	            }
	        }
	    }
	    get variantInfo() {
	        return this.variantToMaterialMap;
	    }
	    addVariant(materialVariant, variantName) {
	        if (!this.ensureVariantIsUnused(variantName)) {
	            return false;
	        }
	        if (!this.modelVariants.has(variantName)) {
	            this.modelVariants.set(variantName, {
	                name: variantName,
	                index: this.modelVariants.size
	            });
	        }
	        const modelVariantData = this.modelVariants.get(variantName);
	        const variantIndex = modelVariantData.index;
	        materialVariant[$variantIndices].add(variantIndex);
	        this.variantToMaterialMap.set(variantIndex, materialVariant);
	        this.materials.set(materialVariant.index, materialVariant);
	        this.updateVariantUserData(variantIndex, materialVariant);
	        return true;
	    }
	    deleteVariant(variantIndex) {
	        if (this.variantInfo.has(variantIndex)) {
	            this.variantInfo.delete(variantIndex);
	            const userDataMap = this.mesh.userData.variantMaterials;
	            if (userDataMap != null) {
	                userDataMap.delete(variantIndex);
	            }
	        }
	    }
	    updateVariantUserData(variantIndex, materialVariant) {
	        materialVariant[$variantIndices].add(variantIndex);
	        this.mesh.userData.variantData = this.modelVariants;
	        this.mesh.userData.variantMaterials = this.mesh.userData.variantMaterials || new Map();
	        const map = this.mesh.userData.variantMaterials;
	        map.set(variantIndex, {
	            material: materialVariant[$correlatedObjects].values().next().value,
	            gltfMaterialIndex: materialVariant.index
	        });
	    }
	    ensureVariantIsUnused(variantName) {
	        const modelVariants = this.modelVariants.get(variantName);
	        if (modelVariants != null && this.variantInfo.has(modelVariants.index)) {
	            console.warn(`Primitive cannot add variant '${variantName}' for this material, it already exists.`);
	            return false;
	        }
	        return true;
	    }
	    constructor(mesh, mvMaterials, modelVariants, correlatedSceneGraph){
	        super(mesh.name);
	        this.materials = new Map();
	        this.variantToMaterialMap = new Map();
	        this.initialMaterialIdx = 0;
	        this.activeMaterialIdx = 0;
	        this.mesh = mesh;
	        const { gltf, threeGLTF, threeObjectMap } = correlatedSceneGraph;
	        this.parser = threeGLTF.parser;
	        this.modelVariants = modelVariants;
	        this.mesh.userData.variantData = modelVariants;
	        const materialMappings = threeObjectMap.get(mesh.material);
	        if (materialMappings.materials != null) {
	            this.initialMaterialIdx = this.activeMaterialIdx = materialMappings.materials;
	        } else {
	            console.error(`Primitive (${mesh.name}) missing initial material reference.`);
	        }
	        const associations = mesh.userData.associations || {};
	        if (associations.meshes == null) {
	            console.error('Mesh is missing primitive index association');
	            return;
	        }
	        const meshElementArray = gltf['meshes'] || [];
	        const gltfPrimitives = meshElementArray[associations.meshes].primitives || [];
	        const gltfPrimitive = gltfPrimitives[associations.primitives];
	        if (gltfPrimitive == null) {
	            console.error('Mesh primitive definition is missing.');
	            return;
	        }
	        if (gltfPrimitive.material != null) {
	            this.materials.set(gltfPrimitive.material, mvMaterials[gltfPrimitive.material]);
	        } else {
	            const defaultIdx = mvMaterials.findIndex((mat)=>{
	                return mat.name === 'Default';
	            });
	            if (defaultIdx >= 0) {
	                this.materials.set(defaultIdx, mvMaterials[defaultIdx]);
	            } else {
	                console.warn('gltfPrimitive has no material!');
	            }
	        }
	        if (gltfPrimitive.extensions && gltfPrimitive.extensions['KHR_materials_variants']) {
	            const variantsExtension = gltfPrimitive.extensions['KHR_materials_variants'];
	            const extensions = threeGLTF.parser.json.extensions;
	            const variantNames = extensions['KHR_materials_variants'].variants;
	            for (const mapping of variantsExtension.mappings){
	                const mvMaterial = mvMaterials[mapping.material];
	                this.materials.set(mapping.material, mvMaterial);
	                for (const variant of mapping.variants){
	                    const { name } = variantNames[variant];
	                    this.variantToMaterialMap.set(variant, mvMaterial);
	                    mvMaterial[$variantIndices].add(variant);
	                    if (!modelVariants.has(name)) {
	                        modelVariants.set(name, {
	                            name,
	                            index: variant
	                        });
	                    }
	                }
	            }
	        }
	    }
	}

	var _a$2, _b$2, _c$1, _d$1, _e$1, _f$1;
	const $materials = Symbol('materials');
	const $hierarchy = Symbol('hierarchy');
	const $roots = Symbol('roots');
	const $primitivesList = Symbol('primitives');
	const $prepareVariantsForExport = Symbol('prepareVariantsForExport');
	const $switchVariant = Symbol('switchVariant');
	const $materialFromPoint = Symbol('materialFromPoint');
	const $nodeFromPoint = Symbol('nodeFromPoint');
	const $nodeFromIndex = Symbol('nodeFromIndex');
	const $variantData = Symbol('variantData');
	const $availableVariants = Symbol('availableVariants');
	const $modelOnUpdate = Symbol('modelOnUpdate');
	const $cloneMaterial = Symbol('cloneMaterial');
	class LazyLoader {
	    constructor(gltf, gltfElementMap, mapKey, doLazyLoad){
	        this.gltf = gltf;
	        this.gltfElementMap = gltfElementMap;
	        this.mapKey = mapKey;
	        this.doLazyLoad = doLazyLoad;
	    }
	}
	 class Model {
	 get materials() {
	        return this[$materials];
	    }
	    [(_a$2 = $materials, _b$2 = $hierarchy, _c$1 = $roots, _d$1 = $primitivesList, _e$1 = $modelOnUpdate, _f$1 = $variantData, $availableVariants)]() {
	        const variants = Array.from(this[$variantData].values());
	        variants.sort((a, b)=>{
	            return a.index - b.index;
	        });
	        return variants.map((data)=>{
	            return data.name;
	        });
	    }
	    getMaterialByName(name) {
	        const matches = this[$materials].filter((material)=>{
	            return material.name === name;
	        });
	        if (matches.length > 0) {
	            return matches[0];
	        }
	        return null;
	    }
	    [$nodeFromIndex](mesh, primitive) {
	        const found = this[$hierarchy].find((node)=>{
	            if (node instanceof PrimitiveNode) {
	                const { meshes, primitives } = node.mesh.userData.associations;
	                if (meshes == mesh && primitives == primitive) {
	                    return true;
	                }
	            }
	            return false;
	        });
	        return found == null ? null : found;
	    }
	    [$nodeFromPoint](hit) {
	        return this[$hierarchy].find((node)=>{
	            if (node instanceof PrimitiveNode) {
	                const primitive = node;
	                if (primitive.mesh === hit.object) {
	                    return true;
	                }
	            }
	            return false;
	        });
	    }
	 [$materialFromPoint](hit) {
	        return this[$nodeFromPoint](hit).getActiveMaterial();
	    }
	 async [$switchVariant](variantName) {
	        for (const primitive of this[$primitivesList]){
	            await primitive.enableVariant(variantName);
	        }
	        for (const material of this.materials){
	            material[$setActive](false);
	        }
	        for (const primitive of this[$primitivesList]){
	            this.materials[primitive.getActiveMaterial().index][$setActive](true);
	        }
	    }
	    async [$prepareVariantsForExport]() {
	        const promises = new Array();
	        for (const primitive of this[$primitivesList]){
	            promises.push(primitive.instantiateVariants());
	        }
	        await Promise.all(promises);
	    }
	    [$cloneMaterial](index, newMaterialName) {
	        const material = this.materials[index];
	        if (!material.isLoaded) {
	            console.error(`Cloning an unloaded material,
           call 'material.ensureLoaded() before cloning the material.`);
	        }
	        const threeMaterialSet = material[$correlatedObjects];
	        const clonedSet = new Set();
	        for (const [i, threeMaterial] of threeMaterialSet.entries()){
	            const clone = threeMaterial.clone();
	            clone.name = newMaterialName + (threeMaterialSet.size > 1 ? '_inst' + i : '');
	            clonedSet.add(clone);
	        }
	        const clonedMaterial = new Material(this[$modelOnUpdate], this[$materials].length, false, this[$variantData], clonedSet, newMaterialName);
	        this[$materials].push(clonedMaterial);
	        return clonedMaterial;
	    }
	    createMaterialInstanceForVariant(originalMaterialIndex, newMaterialName, variantName, activateVariant = true) {
	        let variantMaterialInstance = null;
	        for (const primitive of this[$primitivesList]){
	            const variantData = this[$variantData].get(variantName);
	            if (variantData != null && primitive.variantInfo.has(variantData.index)) {
	                continue;
	            }
	            if (primitive.getMaterial(originalMaterialIndex) == null) {
	                continue;
	            }
	            if (!this.hasVariant(variantName)) {
	                this.createVariant(variantName);
	            }
	            if (variantMaterialInstance == null) {
	                variantMaterialInstance = this[$cloneMaterial](originalMaterialIndex, newMaterialName);
	            }
	            primitive.addVariant(variantMaterialInstance, variantName);
	        }
	        if (activateVariant && variantMaterialInstance != null) {
	            variantMaterialInstance[$setActive](true);
	            this.materials[originalMaterialIndex][$setActive](false);
	            for (const primitive of this[$primitivesList]){
	                primitive.enableVariant(variantName);
	            }
	        }
	        return variantMaterialInstance;
	    }
	    createVariant(variantName) {
	        if (!this[$variantData].has(variantName)) {
	            this[$variantData].set(variantName, {
	                name: variantName,
	                index: this[$variantData].size
	            });
	        } else {
	            console.warn(`Variant '${variantName}'' already exists`);
	        }
	    }
	    hasVariant(variantName) {
	        return this[$variantData].has(variantName);
	    }
	    setMaterialToVariant(materialIndex, targetVariantName) {
	        if (this[$availableVariants]().find((name)=>name === targetVariantName) == null) {
	            console.warn(`Can't add material to '${targetVariantName}', the variant does not exist.'`);
	            return;
	        }
	        if (materialIndex < 0 || materialIndex >= this.materials.length) {
	            console.error(`setMaterialToVariant(): materialIndex is out of bounds.`);
	            return;
	        }
	        for (const primitive of this[$primitivesList]){
	            const material = primitive.getMaterial(materialIndex);
	            if (material != null) {
	                primitive.addVariant(material, targetVariantName);
	            }
	        }
	    }
	    updateVariantName(currentName, newName) {
	        const variantData = this[$variantData].get(currentName);
	        if (variantData == null) {
	            return;
	        }
	        variantData.name = newName;
	        this[$variantData].set(newName, variantData);
	        this[$variantData].delete(currentName);
	    }
	    deleteVariant(variantName) {
	        const variant = this[$variantData].get(variantName);
	        if (variant == null) {
	            return;
	        }
	        for (const material of this.materials){
	            if (material.hasVariant(variantName)) {
	                material[$variantIndices].delete(variant.index);
	            }
	        }
	        for (const primitive of this[$primitivesList]){
	            primitive.deleteVariant(variant.index);
	        }
	        this[$variantData].delete(variantName);
	    }
	    constructor(correlatedSceneGraph, onUpdate = ()=>{}){
	        this[_a$2] = new Array();
	        this[_b$2] = new Array();
	        this[_c$1] = new Array();
	        this[_d$1] = new Array();
	        this[_e$1] = ()=>{};
	        this[_f$1] = new Map();
	        this[$modelOnUpdate] = onUpdate;
	        const { gltf, threeGLTF, gltfElementMap } = correlatedSceneGraph;
	        for (const [i, material] of gltf.materials.entries()){
	            const correlatedMaterial = gltfElementMap.get(material);
	            if (correlatedMaterial != null) {
	                this[$materials].push(new Material(onUpdate, i, true, this[$variantData], correlatedMaterial, material.name));
	            } else {
	                const elementArray = gltf['materials'] || [];
	                const gltfMaterialDef = elementArray[i];
	                const threeMaterialSet = new Set();
	                gltfElementMap.set(gltfMaterialDef, threeMaterialSet);
	                const materialLoadCallback = async ()=>{
	                    const threeMaterial = await threeGLTF.parser.getDependency('material', i);
	                    threeMaterialSet.add(threeMaterial);
	                    return threeMaterial;
	                };
	                this[$materials].push(new Material(onUpdate, i, false, this[$variantData], threeMaterialSet, material.name, new LazyLoader(gltf, gltfElementMap, gltfMaterialDef, materialLoadCallback)));
	            }
	        }
	        const parentMap = new Map();
	        const nodeStack = new Array();
	        for (const object of threeGLTF.scene.children){
	            nodeStack.push(object);
	        }
	        while(nodeStack.length > 0){
	            const object = nodeStack.pop();
	            let node = null;
	            if (object instanceof Mesh) {
	                node = new PrimitiveNode(object, this.materials, this[$variantData], correlatedSceneGraph);
	                this[$primitivesList].push(node);
	            } else {
	                node = new Node$1(object.name);
	            }
	            const parent = parentMap.get(object);
	            if (parent != null) {
	                parent.children.push(node);
	            } else {
	                this[$roots].push(node);
	            }
	            this[$hierarchy].push(node);
	            for (const child of object.children){
	                nodeStack.push(child);
	                parentMap.set(object, node);
	            }
	        }
	    }
	}

	var __decorate$5 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	const $currentGLTF = Symbol('currentGLTF');
	const $originalGltfJson = Symbol('originalGltfJson');
	const $model = Symbol('model');
	const $getOnUpdateMethod = Symbol('getOnUpdateMethod');
	const $buildTexture = Symbol('buildTexture');
	 const SceneGraphMixin = (ModelViewerElement)=>{
	    var _a, _b, _c;
	    class SceneGraphModelViewerElement extends ModelViewerElement {
	         get model() {
	            return this[$model];
	        }
	        get availableVariants() {
	            return this.model ? this.model[$availableVariants]() : [];
	        }
	 get originalGltfJson() {
	            return this[$originalGltfJson];
	        }
	        [(_a = $model, _b = $currentGLTF, _c = $originalGltfJson, $getOnUpdateMethod)]() {
	            return ()=>{
	                this[$needsRender]();
	            };
	        }
	        [$buildTexture](texture) {
	            texture.colorSpace = SRGBColorSpace;
	            texture.wrapS = RepeatWrapping;
	            texture.wrapT = RepeatWrapping;
	            return new Texture(this[$getOnUpdateMethod](), texture);
	        }
	        async createTexture(uri, type = 'image/png') {
	            const { textureUtils } = this[$renderer];
	            const texture = await textureUtils.loadImage(uri, this.withCredentials);
	            texture.userData.mimeType = type;
	            return this[$buildTexture](texture);
	        }
	        async createLottieTexture(uri, quality = 1) {
	            const { textureUtils } = this[$renderer];
	            const texture = await textureUtils.loadLottie(uri, quality, this.withCredentials);
	            return this[$buildTexture](texture);
	        }
	        createVideoTexture(uri) {
	            const video = document.createElement('video');
	            video.crossOrigin = this.withCredentials ? 'use-credentials' : 'anonymous';
	            video.src = uri;
	            video.muted = true;
	            video.playsInline = true;
	            video.loop = true;
	            video.play();
	            const texture = new VideoTexture(video);
	            return this[$buildTexture](texture);
	        }
	        createCanvasTexture() {
	            const canvas = document.createElement('canvas');
	            const texture = new CanvasTexture(canvas);
	            return this[$buildTexture](texture);
	        }
	        async updated(changedProperties) {
	            super.updated(changedProperties);
	            if (changedProperties.has('variantName')) {
	                const updateVariantProgress = this[$progressTracker].beginActivity('variant-update');
	                updateVariantProgress(0.1);
	                const model = this[$model];
	                const { variantName } = this;
	                if (model != null) {
	                    await model[$switchVariant](variantName);
	                    this[$needsRender]();
	                    this.dispatchEvent(new CustomEvent('variant-applied'));
	                }
	                updateVariantProgress(1.0);
	            }
	            if (changedProperties.has('orientation') || changedProperties.has('scale')) {
	                if (!this.loaded) {
	                    return;
	                }
	                const scene = this[$scene];
	                scene.applyTransform();
	                scene.updateBoundingBox();
	                scene.updateShadow();
	                this[$renderer].arRenderer.onUpdateScene();
	                this[$needsRender]();
	            }
	        }
	        [$onModelLoad]() {
	            super[$onModelLoad]();
	            const { currentGLTF } = this[$scene];
	            if (currentGLTF != null) {
	                const { correlatedSceneGraph } = currentGLTF;
	                if (correlatedSceneGraph != null && currentGLTF !== this[$currentGLTF]) {
	                    this[$model] = new Model(correlatedSceneGraph, this[$getOnUpdateMethod]());
	                    this[$originalGltfJson] = JSON.parse(JSON.stringify(correlatedSceneGraph.gltf));
	                }
	                if ('variants' in currentGLTF.userData) {
	                    this.requestUpdate('variantName');
	                }
	            }
	            this[$currentGLTF] = currentGLTF;
	        }
	         async exportScene(options) {
	            const scene = this[$scene];
	            return new Promise(async (resolve, reject)=>{
	                const opts = {
	                    binary: true,
	                    onlyVisible: true,
	                    maxTextureSize: Infinity,
	                    includeCustomExtensions: false,
	                    forceIndices: false
	                };
	                Object.assign(opts, options);
	                opts.animations = scene.animations;
	                opts.truncateDrawRange = true;
	                const shadow = scene.shadow;
	                let visible = false;
	                if (shadow != null) {
	                    visible = shadow.visible;
	                    shadow.visible = false;
	                }
	                await this[$model][$prepareVariantsForExport]();
	                const exporter = new GLTFExporter().register((writer)=>new GLTFExporterMaterialsVariantsExtension(writer));
	                exporter.parse(scene.model, (gltf)=>{
	                    return resolve(new Blob([
	                        opts.binary ? gltf : JSON.stringify(gltf)
	                    ], {
	                        type: opts.binary ? 'application/octet-stream' : 'application/json'
	                    }));
	                }, ()=>{
	                    return reject('glTF export failed');
	                }, opts);
	                if (shadow != null) {
	                    shadow.visible = visible;
	                }
	            });
	        }
	        materialFromPoint(pixelX, pixelY) {
	            const model = this[$model];
	            if (model == null) {
	                return null;
	            }
	            const scene = this[$scene];
	            const ndcCoords = scene.getNDC(pixelX, pixelY);
	            const hit = scene.hitFromPoint(ndcCoords);
	            if (hit == null || hit.face == null) {
	                return null;
	            }
	            return model[$materialFromPoint](hit);
	        }
	        constructor(){
	            super(...arguments);
	            this[_a] = undefined;
	            this[_b] = null;
	            this[_c] = null;
	            this.variantName = null;
	            this.orientation = '0 0 0';
	            this.scale = '1 1 1';
	        }
	    }
	    __decorate$5([
	        n$2({
	            type: String,
	            attribute: 'variant-name'
	        })
	    ], SceneGraphModelViewerElement.prototype, "variantName", void 0);
	    __decorate$5([
	        n$2({
	            type: String,
	            attribute: 'orientation'
	        })
	    ], SceneGraphModelViewerElement.prototype, "orientation", void 0);
	    __decorate$5([
	        n$2({
	            type: String,
	            attribute: 'scale'
	        })
	    ], SceneGraphModelViewerElement.prototype, "scale", void 0);
	    return SceneGraphModelViewerElement;
	};

	class GroundedSkybox extends Mesh {
	    get map() {
	        return this.material.map;
	    }
	    set map(skybox) {
	        this.material.map = skybox;
	    }
	    isUsable() {
	        return this.height > 0 && this.radius > 0 && this.geometry != null && this.map != null;
	    }
	    updateGeometry(height = this.height, radius = this.radius, resolution = 128) {
	        if (height != this.height || radius != this.radius || resolution != this.resolution) {
	            this.height = height;
	            this.radius = radius;
	            this.resolution = resolution;
	            if (height > 0 && radius > 0) {
	                this.geometry.dispose();
	                this.geometry = makeGeometry(height, radius, resolution);
	            }
	        }
	    }
	    constructor(){
	        super(undefined, new MeshBasicMaterial({
	            depthWrite: false
	        }));
	        this.height = 0;
	        this.radius = 0;
	        this.resolution = 0;
	        this.userData.noHit = true;
	    }
	}
	function makeGeometry(height, radius, resolution) {
	    const geometry = new SphereGeometry(radius, 2 * resolution, resolution);
	    geometry.scale(1, 1, -1);
	    const pos = geometry.getAttribute('position');
	    const tmp = new Vector3();
	    for(let i = 0; i < pos.count; ++i){
	        tmp.fromBufferAttribute(pos, i);
	        if (tmp.y < 0) {
	            const y1 = -height * 3 / 2;
	            const f = tmp.y < y1 ? -height / tmp.y : 1 - tmp.y * tmp.y / (3 * y1 * y1);
	            tmp.multiplyScalar(f);
	            tmp.toArray(pos.array, 3 * i);
	        }
	    }
	    pos.needsUpdate = true;
	    return geometry;
	}

	const a = new Vector3();
	const b = new Vector3();
	const c = new Vector3();
	const mat = new Matrix3();
	const triangle = new Triangle();
	const quat = new Quaternion();
	 class Hotspot extends CSS2DObject {
	    get facingCamera() {
	        return !this.element.classList.contains('hide');
	    }
	 show() {
	        if (!this.facingCamera || !this.initialized) {
	            this.updateVisibility(true);
	        }
	    }
	 hide() {
	        if (this.facingCamera || !this.initialized) {
	            this.updateVisibility(false);
	        }
	    }
	 increment() {
	        this.referenceCount++;
	    }
	 decrement() {
	        if (this.referenceCount > 0) {
	            --this.referenceCount;
	        }
	        return this.referenceCount === 0;
	    }
	 updatePosition(position) {
	        if (position == null) return;
	        const positionNodes = parseExpressions(position)[0].terms;
	        for(let i = 0; i < 3; ++i){
	            this.position.setComponent(i, normalizeUnit(positionNodes[i]).number);
	        }
	        this.updateMatrixWorld();
	    }
	 updateNormal(normal) {
	        if (normal == null) return;
	        const normalNodes = parseExpressions(normal)[0].terms;
	        for(let i = 0; i < 3; ++i){
	            this.normal.setComponent(i, normalNodes[i].number);
	        }
	    }
	    updateSurface() {
	        const { mesh, tri, bary } = this;
	        if (mesh == null || tri == null || bary == null) {
	            return;
	        }
	        mesh.getVertexPosition(tri.x, a);
	        mesh.getVertexPosition(tri.y, b);
	        mesh.getVertexPosition(tri.z, c);
	        a.toArray(mat.elements, 0);
	        b.toArray(mat.elements, 3);
	        c.toArray(mat.elements, 6);
	        this.position.copy(bary).applyMatrix3(mat);
	        const target = this.parent;
	        target.worldToLocal(mesh.localToWorld(this.position));
	        triangle.set(a, b, c);
	        triangle.getNormal(this.normal).transformDirection(mesh.matrixWorld);
	        const pivot = target.parent;
	        quat.setFromAxisAngle(a.set(0, 1, 0), -pivot.rotation.y);
	        this.normal.applyQuaternion(quat);
	    }
	    orient(radians) {
	        this.pivot.style.transform = `rotate(${radians}rad)`;
	    }
	    updateVisibility(show) {
	        this.element.classList.toggle('hide', !show);
	        this.slot.assignedNodes().forEach((node)=>{
	            if (node.nodeType !== Node.ELEMENT_NODE) {
	                return;
	            }
	            const element = node;
	            const visibilityAttribute = element.dataset.visibilityAttribute;
	            if (visibilityAttribute != null) {
	                const attributeName = `data-${visibilityAttribute}`;
	                element.toggleAttribute(attributeName, show);
	            }
	            element.dispatchEvent(new CustomEvent('hotspot-visibility', {
	                detail: {
	                    visible: show
	                }
	            }));
	        });
	        this.initialized = true;
	    }
	    constructor(config){
	        super(document.createElement('div'));
	        this.normal = new Vector3(0, 1, 0);
	        this.initialized = false;
	        this.referenceCount = 1;
	        this.pivot = document.createElement('div');
	        this.slot = document.createElement('slot');
	        this.element.classList.add('annotation-wrapper');
	        this.slot.name = config.name;
	        this.element.appendChild(this.pivot);
	        this.pivot.appendChild(this.slot);
	        this.updatePosition(config.position);
	        this.updateNormal(config.normal);
	        this.surface = config.surface;
	    }
	}

	/**
	 * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
	 * - see http://www.cake23.de/traveling-wavefronts-lit-up.html
	 *
	 * - 9 samples per pass
	 * - standard deviation 2.7
	 * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
	 */ const HorizontalBlurShader = {
	    name: 'HorizontalBlurShader',
	    uniforms: {
	        'tDiffuse': {
	            value: null
	        },
	        'h': {
	            value: 1.0 / 512.0
	        }
	    },
	    vertexShader: /* glsl */ `

		varying vec2 vUv;

		void main() {

			vUv = uv;
			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );

		}`,
	    fragmentShader: /* glsl */ `

		uniform sampler2D tDiffuse;
		uniform float h;

		varying vec2 vUv;

		void main() {

			vec4 sum = vec4( 0.0 );

			sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * h, vUv.y ) ) * 0.051;
			sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * h, vUv.y ) ) * 0.0918;
			sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * h, vUv.y ) ) * 0.12245;
			sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * h, vUv.y ) ) * 0.1531;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
			sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * h, vUv.y ) ) * 0.1531;
			sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * h, vUv.y ) ) * 0.12245;
			sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * h, vUv.y ) ) * 0.0918;
			sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * h, vUv.y ) ) * 0.051;

			gl_FragColor = sum;

		}`
	};

	/**
	 * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
	 * - see http://www.cake23.de/traveling-wavefronts-lit-up.html
	 *
	 * - 9 samples per pass
	 * - standard deviation 2.7
	 * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
	 */ const VerticalBlurShader = {
	    name: 'VerticalBlurShader',
	    uniforms: {
	        'tDiffuse': {
	            value: null
	        },
	        'v': {
	            value: 1.0 / 512.0
	        }
	    },
	    vertexShader: /* glsl */ `

		varying vec2 vUv;

		void main() {

			vUv = uv;
			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );

		}`,
	    fragmentShader: /* glsl */ `

		uniform sampler2D tDiffuse;
		uniform float v;

		varying vec2 vUv;

		void main() {

			vec4 sum = vec4( 0.0 );

			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * v ) ) * 0.051;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * v ) ) * 0.0918;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * v ) ) * 0.12245;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * v ) ) * 0.1531;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * v ) ) * 0.1531;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * v ) ) * 0.12245;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * v ) ) * 0.0918;
			sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * v ) ) * 0.051;

			gl_FragColor = sum;

		}`
	};

	/**
	 * Returns a value linearly interpolated from two known points based on the given interval -
	 * `t = 0` will return `x` and `t = 1` will return `y`.
	 *
	 * @param {number} x - The start point
	 * @param {number} y - The end point.
	 * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
	 * @return {number} The interpolated value.
	 */ function lerp(x, y, t) {
	    return (1 - t) * x + t * y;
	}

	const LOG_MAX_RESOLUTION = 9;
	const LOG_MIN_RESOLUTION = 6;
	const ANIMATION_SCALING = 2;
	const DEFAULT_HARD_INTENSITY = 0.3;
	 class Shadow extends Object3D {
	 setScene(scene, softness, side) {
	        const { boundingBox, size, rotation, position } = this;
	        this.isAnimated = scene.animationNames.length > 0;
	        this.boundingBox.copy(scene.boundingBox);
	        this.size.copy(scene.size);
	        this.maxDimension = Math.max(size.x, size.y, size.z) * (this.isAnimated ? ANIMATION_SCALING : 1);
	        this.boundingBox.getCenter(position);
	        if (side === 'back') {
	            const { min, max } = boundingBox;
	            [min.y, min.z] = [
	                min.z,
	                min.y
	            ];
	            [max.y, max.z] = [
	                max.z,
	                max.y
	            ];
	            [size.y, size.z] = [
	                size.z,
	                size.y
	            ];
	            rotation.x = Math.PI / 2;
	            rotation.y = Math.PI;
	        } else {
	            rotation.x = 0;
	            rotation.y = 0;
	        }
	        if (this.isAnimated) {
	            const minY = boundingBox.min.y;
	            const maxY = boundingBox.max.y;
	            size.y = this.maxDimension;
	            boundingBox.expandByVector(size.subScalar(this.maxDimension).multiplyScalar(-0.5));
	            boundingBox.min.y = minY;
	            boundingBox.max.y = maxY;
	            size.set(this.maxDimension, maxY - minY, this.maxDimension);
	        }
	        if (side === 'bottom') {
	            position.y = boundingBox.min.y;
	        } else {
	            position.z = boundingBox.min.y;
	        }
	        this.setSoftness(softness);
	    }
	 setSoftness(softness) {
	        this.softness = softness;
	        const { size, camera } = this;
	        const scaleY = this.isAnimated ? ANIMATION_SCALING : 1;
	        const resolution = scaleY * Math.pow(2, LOG_MAX_RESOLUTION - softness * (LOG_MAX_RESOLUTION - LOG_MIN_RESOLUTION));
	        this.setMapSize(resolution);
	        const softFar = size.y / 2;
	        const hardFar = size.y * scaleY;
	        camera.near = 0;
	        camera.far = lerp(hardFar, softFar, softness);
	        this.depthMaterial.opacity = 1.0 / softness;
	        camera.updateProjectionMatrix();
	        this.setIntensity(this.intensity);
	        this.setOffset(0);
	    }
	 setMapSize(maxMapSize) {
	        const { size } = this;
	        if (this.isAnimated) {
	            maxMapSize *= ANIMATION_SCALING;
	        }
	        const baseWidth = Math.floor(size.x > size.z ? maxMapSize : maxMapSize * size.x / size.z);
	        const baseHeight = Math.floor(size.x > size.z ? maxMapSize * size.z / size.x : maxMapSize);
	        const TAP_WIDTH = 10;
	        const width = TAP_WIDTH + baseWidth;
	        const height = TAP_WIDTH + baseHeight;
	        if (this.renderTarget != null && (this.renderTarget.width !== width || this.renderTarget.height !== height)) {
	            this.renderTarget.dispose();
	            this.renderTarget = null;
	            this.renderTargetBlur.dispose();
	            this.renderTargetBlur = null;
	        }
	        if (this.renderTarget == null) {
	            const params = {
	                format: RGBAFormat
	            };
	            this.renderTarget = new WebGLRenderTarget(width, height, params);
	            this.renderTargetBlur = new WebGLRenderTarget(width, height, params);
	            this.floor.material.map = this.renderTarget.texture;
	        }
	        this.camera.scale.set(size.x * (1 + TAP_WIDTH / baseWidth), size.z * (1 + TAP_WIDTH / baseHeight), 1);
	        this.needsUpdate = true;
	    }
	 setIntensity(intensity) {
	        this.intensity = intensity;
	        if (intensity > 0) {
	            this.visible = true;
	            this.floor.visible = true;
	            this.floor.material.opacity = intensity * lerp(DEFAULT_HARD_INTENSITY, 1, this.softness * this.softness);
	        } else {
	            this.visible = false;
	            this.floor.visible = false;
	        }
	    }
	    getIntensity() {
	        return this.intensity;
	    }
	 setOffset(offset) {
	        this.floor.position.z = -offset + this.gap();
	    }
	    gap() {
	        return 0.001 * this.maxDimension;
	    }
	    render(renderer, scene) {
	        scene.overrideMaterial = this.depthMaterial;
	        const initialClearAlpha = renderer.getClearAlpha();
	        renderer.setClearAlpha(0);
	        this.floor.visible = false;
	        const xrEnabled = renderer.xr.enabled;
	        renderer.xr.enabled = false;
	        const oldRenderTarget = renderer.getRenderTarget();
	        renderer.setRenderTarget(this.renderTarget);
	        renderer.render(scene, this.camera);
	        scene.overrideMaterial = null;
	        this.floor.visible = true;
	        this.blurShadow(renderer);
	        renderer.xr.enabled = xrEnabled;
	        renderer.setRenderTarget(oldRenderTarget);
	        renderer.setClearAlpha(initialClearAlpha);
	    }
	    blurShadow(renderer) {
	        const { camera, horizontalBlurMaterial, verticalBlurMaterial, renderTarget, renderTargetBlur, blurPlane } = this;
	        blurPlane.visible = true;
	        blurPlane.material = horizontalBlurMaterial;
	        horizontalBlurMaterial.uniforms.h.value = 1 / this.renderTarget.width;
	        horizontalBlurMaterial.uniforms.tDiffuse.value = this.renderTarget.texture;
	        renderer.setRenderTarget(renderTargetBlur);
	        renderer.render(blurPlane, camera);
	        blurPlane.material = verticalBlurMaterial;
	        verticalBlurMaterial.uniforms.v.value = 1 / this.renderTarget.height;
	        verticalBlurMaterial.uniforms.tDiffuse.value = this.renderTargetBlur.texture;
	        renderer.setRenderTarget(renderTarget);
	        renderer.render(blurPlane, camera);
	        blurPlane.visible = false;
	    }
	    dispose() {
	        if (this.renderTarget != null) {
	            this.renderTarget.dispose();
	        }
	        if (this.renderTargetBlur != null) {
	            this.renderTargetBlur.dispose();
	        }
	        this.depthMaterial.dispose();
	        this.horizontalBlurMaterial.dispose();
	        this.verticalBlurMaterial.dispose();
	        this.floor.material.dispose();
	        this.floor.geometry.dispose();
	        this.blurPlane.geometry.dispose();
	        this.removeFromParent();
	    }
	    constructor(scene, softness, side){
	        super();
	        this.camera = new OrthographicCamera();
	        this.renderTarget = null;
	        this.renderTargetBlur = null;
	        this.depthMaterial = new MeshDepthMaterial();
	        this.horizontalBlurMaterial = new ShaderMaterial(HorizontalBlurShader);
	        this.verticalBlurMaterial = new ShaderMaterial(VerticalBlurShader);
	        this.intensity = 0;
	        this.softness = 1;
	        this.boundingBox = new Box3;
	        this.size = new Vector3;
	        this.maxDimension = 0;
	        this.isAnimated = false;
	        this.needsUpdate = false;
	        const { camera } = this;
	        camera.rotation.x = Math.PI / 2;
	        camera.left = -0.5;
	        camera.right = 0.5;
	        camera.bottom = -0.5;
	        camera.top = 0.5;
	        this.add(camera);
	        const plane = new PlaneGeometry();
	        const shadowMaterial = new MeshBasicMaterial({
	            opacity: 1,
	            transparent: true,
	            side: BackSide
	        });
	        this.floor = new Mesh(plane, shadowMaterial);
	        this.floor.userData.noHit = true;
	        camera.add(this.floor);
	        this.blurPlane = new Mesh(plane);
	        this.blurPlane.visible = false;
	        camera.add(this.blurPlane);
	        scene.target.add(this);
	        this.depthMaterial.onBeforeCompile = function(shader) {
	            shader.fragmentShader = shader.fragmentShader.replace('gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );', 'gl_FragColor = vec4( vec3( 0.0 ), ( 1.0 - fragCoordZ ) * opacity );');
	        };
	        this.depthMaterial.side = DoubleSide;
	        this.horizontalBlurMaterial.depthTest = false;
	        this.verticalBlurMaterial.depthTest = false;
	        this.setScene(scene, softness, side);
	    }
	}

	const GROUNDED_SKYBOX_SIZE = 10;
	const MIN_SHADOW_RATIO = 100;
	const view = new Vector3();
	const target = new Vector3();
	const normalWorld = new Vector3();
	const raycaster = new Raycaster();
	const vector3 = new Vector3();
	const ndc = new Vector2();
	 class ModelScene extends Scene {
	 get context() {
	        return this.canvas.getContext('2d');
	    }
	    getCamera() {
	        return this.xrCamera != null ? this.xrCamera : this.camera;
	    }
	    queueRender() {
	        this.isDirty = true;
	    }
	    shouldRender() {
	        return this.isDirty;
	    }
	    hasRendered() {
	        this.isDirty = false;
	    }
	    forceRescale() {
	        this.scaleStep = -1;
	        this.queueRender();
	    }
	 async setObject(model) {
	        this.reset();
	        this._model = model;
	        this.target.add(model);
	        await this.setupScene();
	    }
	 async setSource(url, progressCallback = ()=>{}) {
	        if (!url || url === this.url) {
	            progressCallback(1);
	            return;
	        }
	        this.reset();
	        this.url = url;
	        if (this.externalRenderer != null) {
	            const framingInfo = await this.externalRenderer.load(progressCallback);
	            this.boundingSphere.radius = framingInfo.framedRadius;
	            this.idealAspect = framingInfo.fieldOfViewAspect;
	            return;
	        }
	        if (this.cancelPendingSourceChange != null) {
	            this.cancelPendingSourceChange();
	            this.cancelPendingSourceChange = null;
	        }
	        let gltf;
	        try {
	            gltf = await new Promise(async (resolve, reject)=>{
	                this.cancelPendingSourceChange = ()=>reject();
	                try {
	                    const result = await this.element[$renderer].loader.load(url, this.element, progressCallback);
	                    resolve(result);
	                } catch (error) {
	                    reject(error);
	                }
	            });
	        } catch (error) {
	            if (error == null) {
	                return;
	            }
	            throw error;
	        }
	        this.cancelPendingSourceChange = null;
	        this.reset();
	        this.url = url;
	        this._currentGLTF = gltf;
	        if (gltf != null) {
	            this._model = gltf.scene;
	            this.target.add(gltf.scene);
	        }
	        const { animations } = gltf;
	        const animationsByName = new Map();
	        const animationNames = [];
	        for (const animation of animations){
	            animationsByName.set(animation.name, animation);
	            animationNames.push(animation.name);
	        }
	        this.animations = animations;
	        this.animationsByName = animationsByName;
	        this.animationNames = animationNames;
	        await this.setupScene();
	    }
	    async setupScene() {
	        this.applyTransform();
	        this.updateBoundingBox();
	        await this.updateFraming();
	        this.updateShadow();
	        this.setShadowIntensity(this.shadowIntensity);
	        this.setGroundedSkybox();
	    }
	    reset() {
	        this.url = null;
	        this.renderCount = 0;
	        this.queueRender();
	        if (this.shadow != null) {
	            this.shadow.setIntensity(0);
	        }
	        this.bakedShadows.clear();
	        const { _model } = this;
	        if (_model != null) {
	            _model.removeFromParent();
	            this._model = null;
	        }
	        const gltf = this._currentGLTF;
	        if (gltf != null) {
	            gltf.dispose();
	            this._currentGLTF = null;
	        }
	        if (this.currentAnimationAction != null) {
	            this.currentAnimationAction.stop();
	            this.currentAnimationAction = null;
	        }
	        this.mixer.stopAllAction();
	        this.mixer.uncacheRoot(this);
	    }
	    dispose() {
	        this.reset();
	        if (this.shadow != null) {
	            this.shadow.dispose();
	            this.shadow = null;
	        }
	        this.element[$currentGLTF] = null;
	        this.element[$originalGltfJson] = null;
	        this.element[$model] = null;
	    }
	    get currentGLTF() {
	        return this._currentGLTF;
	    }
	 setSize(width, height) {
	        if (this.width === width && this.height === height) {
	            return;
	        }
	        this.width = Math.max(width, 1);
	        this.height = Math.max(height, 1);
	        this.annotationRenderer.setSize(width, height);
	        this.aspect = this.width / this.height;
	        if (this.externalRenderer != null) {
	            const dpr = window.devicePixelRatio;
	            this.externalRenderer.resize(width * dpr, height * dpr);
	        }
	        this.queueRender();
	    }
	    markBakedShadow(mesh) {
	        mesh.userData.noHit = true;
	        this.bakedShadows.add(mesh);
	    }
	    unmarkBakedShadow(mesh) {
	        mesh.userData.noHit = false;
	        mesh.visible = true;
	        this.bakedShadows.delete(mesh);
	        this.boundingBox.expandByObject(mesh);
	    }
	    findBakedShadows(group) {
	        const boundingBox = new Box3();
	        group.traverse((object)=>{
	            const mesh = object;
	            if (!mesh.material) {
	                return;
	            }
	            const material = mesh.material;
	            if (!material.transparent) {
	                return;
	            }
	            boundingBox.setFromObject(mesh);
	            const size = boundingBox.getSize(vector3);
	            const minDim = Math.min(size.x, size.y, size.z);
	            const maxDim = Math.max(size.x, size.y, size.z);
	            if (maxDim < MIN_SHADOW_RATIO * minDim) {
	                return;
	            }
	            this.markBakedShadow(mesh);
	        });
	    }
	    checkBakedShadows() {
	        const { min, max } = this.boundingBox;
	        const shadowBox = new Box3();
	        this.boundingBox.getSize(this.size);
	        for (const mesh of this.bakedShadows){
	            shadowBox.setFromObject(mesh);
	            if (shadowBox.min.y < min.y + this.size.y / MIN_SHADOW_RATIO && shadowBox.min.x <= min.x && shadowBox.max.x >= max.x && shadowBox.min.z <= min.z && shadowBox.max.z >= max.z) {
	                continue;
	            }
	            if (shadowBox.min.z < min.z + this.size.z / MIN_SHADOW_RATIO && shadowBox.min.x <= min.x && shadowBox.max.x >= max.x && shadowBox.min.y <= min.y && shadowBox.max.y >= max.y) {
	                continue;
	            }
	            this.unmarkBakedShadow(mesh);
	        }
	    }
	    applyTransform() {
	        const { model } = this;
	        if (model == null) {
	            return;
	        }
	        const orientation = parseExpressions(this.element.orientation)[0].terms;
	        const roll = normalizeUnit(orientation[0]).number;
	        const pitch = normalizeUnit(orientation[1]).number;
	        const yaw = normalizeUnit(orientation[2]).number;
	        model.quaternion.setFromEuler(new Euler(pitch, yaw, roll, 'YXZ'));
	        const scale = parseExpressions(this.element.scale)[0].terms;
	        model.scale.set(scale[0].number, scale[1].number, scale[2].number);
	    }
	    updateBoundingBox() {
	        const { model } = this;
	        if (model == null) {
	            return;
	        }
	        this.target.remove(model);
	        this.findBakedShadows(model);
	        const bound = (box, vertex)=>{
	            return box.expandByPoint(vertex);
	        };
	        this.setBakedShadowVisibility(false);
	        this.boundingBox = reduceVertices(model, bound, new Box3());
	        if (this.boundingBox.isEmpty()) {
	            this.setBakedShadowVisibility(true);
	            this.bakedShadows.forEach((mesh)=>this.unmarkBakedShadow(mesh));
	            this.boundingBox = reduceVertices(model, bound, new Box3());
	        }
	        this.checkBakedShadows();
	        this.setBakedShadowVisibility();
	        this.boundingBox.getSize(this.size);
	        this.target.add(model);
	    }
	 async updateFraming() {
	        const { model } = this;
	        if (model == null) {
	            return;
	        }
	        this.target.remove(model);
	        this.setBakedShadowVisibility(false);
	        const { center } = this.boundingSphere;
	        this.element.requestUpdate('cameraTarget');
	        await this.element.updateComplete;
	        center.copy(this.getTarget());
	        const radiusSquared = (value, vertex)=>{
	            return Math.max(value, center.distanceToSquared(vertex));
	        };
	        this.boundingSphere.radius = Math.sqrt(reduceVertices(model, radiusSquared, 0));
	        const horizontalTanFov = (value, vertex)=>{
	            vertex.sub(center);
	            const radiusXZ = Math.sqrt(vertex.x * vertex.x + vertex.z * vertex.z);
	            return Math.max(value, radiusXZ / (this.idealCameraDistance() - Math.abs(vertex.y)));
	        };
	        this.idealAspect = reduceVertices(model, horizontalTanFov, 0) / Math.tan(this.framedFoVDeg / 2 * Math.PI / 180);
	        this.setBakedShadowVisibility();
	        this.target.add(model);
	    }
	    setBakedShadowVisibility(visible = this.shadowIntensity <= 0) {
	        for (const shadow of this.bakedShadows){
	            shadow.visible = visible;
	        }
	    }
	    idealCameraDistance() {
	        const halfFovRad = this.framedFoVDeg / 2 * Math.PI / 180;
	        return this.boundingSphere.radius / Math.sin(halfFovRad);
	    }
	 adjustedFoV(fovDeg) {
	        const vertical = Math.tan(fovDeg / 2 * Math.PI / 180) * Math.max(1, this.idealAspect / this.aspect);
	        return 2 * Math.atan(vertical) * 180 / Math.PI;
	    }
	    getNDC(clientX, clientY) {
	        if (this.xrCamera != null) {
	            ndc.set(clientX / window.screen.width, clientY / window.screen.height);
	        } else {
	            const rect = this.element.getBoundingClientRect();
	            ndc.set((clientX - rect.x) / this.width, (clientY - rect.y) / this.height);
	        }
	        ndc.multiplyScalar(2).subScalar(1);
	        ndc.y *= -1;
	        return ndc;
	    }
	 getSize() {
	        return {
	            width: this.width,
	            height: this.height
	        };
	    }
	    setEnvironmentAndSkybox(environment, skybox) {
	        if (this.element[$renderer].arRenderer.presentedScene === this) {
	            return;
	        }
	        this.environment = environment;
	        this.setBackground(skybox);
	        this.queueRender();
	    }
	    setBackground(skybox) {
	        this.groundedSkybox.map = skybox;
	        if (this.groundedSkybox.isUsable()) {
	            this.target.add(this.groundedSkybox);
	            this.background = null;
	        } else {
	            this.target.remove(this.groundedSkybox);
	            this.background = skybox;
	        }
	    }
	    farRadius() {
	        return this.boundingSphere.radius * (this.groundedSkybox.parent != null ? GROUNDED_SKYBOX_SIZE : 1);
	    }
	    setGroundedSkybox() {
	        const heightNode = parseExpressions(this.element.skyboxHeight)[0].terms[0];
	        const height = normalizeUnit(heightNode).number;
	        const radius = GROUNDED_SKYBOX_SIZE * this.boundingSphere.radius;
	        this.groundedSkybox.updateGeometry(height, radius);
	        this.groundedSkybox.position.y = height - (this.shadow ? 2 * this.shadow.gap() : 0);
	        this.setBackground(this.groundedSkybox.map);
	    }
	 setTarget(modelX, modelY, modelZ) {
	        this.goalTarget.set(-modelX, -modelY, -modelZ);
	    }
	 setTargetDamperDecayTime(decayMilliseconds) {
	        this.targetDamperX.setDecayTime(decayMilliseconds);
	        this.targetDamperY.setDecayTime(decayMilliseconds);
	        this.targetDamperZ.setDecayTime(decayMilliseconds);
	    }
	 getTarget() {
	        return this.goalTarget.clone().multiplyScalar(-1);
	    }
	 getDynamicTarget() {
	        return this.target.position.clone().multiplyScalar(-1);
	    }
	 jumpToGoal() {
	        this.updateTarget(SETTLING_TIME);
	    }
	 updateTarget(delta) {
	        const goal = this.goalTarget;
	        const target = this.target.position;
	        if (!goal.equals(target)) {
	            const normalization = this.boundingSphere.radius / 10;
	            let { x, y, z } = target;
	            x = this.targetDamperX.update(x, goal.x, delta, normalization);
	            y = this.targetDamperY.update(y, goal.y, delta, normalization);
	            z = this.targetDamperZ.update(z, goal.z, delta, normalization);
	            this.groundedSkybox.position.x = -x;
	            this.groundedSkybox.position.z = -z;
	            this.target.position.set(x, y, z);
	            this.target.updateMatrixWorld();
	            this.queueRender();
	            return true;
	        } else {
	            return false;
	        }
	    }
	 pointTowards(worldX, worldZ) {
	        const { x, z } = this.position;
	        this.yaw = Math.atan2(worldX - x, worldZ - z);
	    }
	    get model() {
	        return this._model;
	    }
	 set yaw(radiansY) {
	        this.pivot.rotation.y = radiansY;
	        this.groundedSkybox.rotation.y = -radiansY;
	        this.queueRender();
	    }
	    get yaw() {
	        return this.pivot.rotation.y;
	    }
	    set animationTime(value) {
	        this.mixer.setTime(value);
	        this.queueShadowRender();
	    }
	    get animationTime() {
	        if (this.currentAnimationAction != null) {
	            const loopCount = Math.max(this.currentAnimationAction._loopCount, 0);
	            if (this.currentAnimationAction.loop === LoopPingPong && (loopCount & 1) === 1) {
	                return this.duration - this.currentAnimationAction.time;
	            } else {
	                return this.currentAnimationAction.time;
	            }
	        }
	        return 0;
	    }
	    set animationTimeScale(value) {
	        this.mixer.timeScale = value;
	    }
	    get animationTimeScale() {
	        return this.mixer.timeScale;
	    }
	    get duration() {
	        if (this.currentAnimationAction != null && this.currentAnimationAction.getClip()) {
	            return this.currentAnimationAction.getClip().duration;
	        }
	        return 0;
	    }
	    get hasActiveAnimation() {
	        return this.currentAnimationAction != null;
	    }
	 playAnimation(name = null, crossfadeTime = 0, loopMode = LoopRepeat, repetitionCount = Infinity) {
	        if (this._currentGLTF == null) {
	            return;
	        }
	        const { animations } = this;
	        if (animations == null || animations.length === 0) {
	            return;
	        }
	        let animationClip = null;
	        if (name != null) {
	            animationClip = this.animationsByName.get(name);
	            if (animationClip == null) {
	                const parsedAnimationIndex = parseInt(name);
	                if (!isNaN(parsedAnimationIndex) && parsedAnimationIndex >= 0 && parsedAnimationIndex < animations.length) {
	                    animationClip = animations[parsedAnimationIndex];
	                }
	            }
	        }
	        if (animationClip == null) {
	            animationClip = animations[0];
	        }
	        try {
	            const { currentAnimationAction: lastAnimationAction } = this;
	            const action = this.mixer.clipAction(animationClip, this);
	            if (action.timeScale != this.element.timeScale) {
	                action.timeScale = this.element.timeScale;
	            }
	            this.currentAnimationAction = action;
	            if (this.element.paused) {
	                this.mixer.stopAllAction();
	            } else {
	                action.paused = false;
	                if (lastAnimationAction != null && action !== lastAnimationAction) {
	                    action.crossFadeFrom(lastAnimationAction, crossfadeTime, false);
	                } else if (this.animationTimeScale > 0 && this.animationTime == this.duration) {
	                    this.animationTime = 0;
	                }
	            }
	            action.setLoop(loopMode, repetitionCount);
	            action.enabled = true;
	            action.clampWhenFinished = true;
	            action.play();
	        } catch (error) {
	            console.error(error);
	        }
	    }
	    appendAnimation(name = '', loopMode = LoopRepeat, repetitionCount = Infinity, weight = 1, timeScale = 1, fade = false, warp = false, relativeWarp = true, time = null, needsToStop = false) {
	        if (this._currentGLTF == null || name === this.element.animationName) {
	            return;
	        }
	        const { animations } = this;
	        if (animations == null || animations.length === 0) {
	            return;
	        }
	        let animationClip = null;
	        const defaultFade = 1.25;
	        if (name) {
	            animationClip = this.animationsByName.get(name);
	        }
	        if (animationClip == null) {
	            return;
	        }
	        if (typeof repetitionCount === 'string') {
	            if (!isNaN(repetitionCount)) {
	                repetitionCount = Math.max(parseInt(repetitionCount), 1);
	            } else {
	                repetitionCount = Infinity;
	                console.warn('Invalid repetitionCount value, repetitionCount is set to Infinity');
	            }
	        } else if (typeof repetitionCount === 'number' && repetitionCount < 1) {
	            repetitionCount = 1;
	        }
	        if (repetitionCount === 1 && loopMode !== LoopOnce) {
	            loopMode = LoopOnce;
	        }
	        if (typeof weight === 'string') {
	            if (!isNaN(weight)) {
	                weight = parseFloat(weight);
	            } else {
	                weight = 1;
	                console.warn('Invalid weight value, weight is set to 1');
	            }
	        }
	        if (typeof timeScale === 'string') {
	            if (!isNaN(timeScale)) {
	                timeScale = parseFloat(timeScale);
	            } else {
	                timeScale = 1;
	                console.warn('Invalid timeScale value, timeScale is set to 1');
	            }
	        }
	        if (typeof fade === 'string') {
	            if (fade.toLowerCase().trim() === 'true') {
	                fade = true;
	            } else if (fade.toLowerCase().trim() === 'false') {
	                fade = false;
	            } else if (!isNaN(fade)) {
	                fade = parseFloat(fade);
	            } else {
	                fade = false;
	                console.warn('Invalid fade value, fade is set to false');
	            }
	        }
	        if (typeof warp === 'string') {
	            if (warp.toLowerCase().trim() === 'true') {
	                warp = true;
	            } else if (warp.toLowerCase().trim() === 'false') {
	                warp = false;
	            } else if (!isNaN(warp)) {
	                warp = parseFloat(warp);
	            } else {
	                warp = false;
	                console.warn('Invalid warp value, warp is set to false');
	            }
	        }
	        if (typeof time === 'string') {
	            if (!isNaN(time)) {
	                time = parseFloat(time);
	            }
	        }
	        try {
	            const action = this.mixer.existingAction(animationClip) || this.mixer.clipAction(animationClip, this);
	            const currentTimeScale = action.timeScale;
	            if (needsToStop && this.appendedAnimations.includes(name)) {
	                if (!this.markedAnimations.map((e)=>e.name).includes(name)) {
	                    this.markedAnimations.push({
	                        name,
	                        loopMode,
	                        repetitionCount
	                    });
	                }
	            }
	            if (typeof time === 'number') {
	                action.time = Math.min(Math.max(time, 0), animationClip.duration);
	            }
	            if (typeof fade === 'boolean' && fade) {
	                action.fadeIn(defaultFade);
	            } else if (typeof fade === 'number') {
	                action.fadeIn(Math.max(fade, 0));
	            } else {
	                if (weight >= 0) {
	                    action.weight = Math.min(Math.max(weight, 0), 1);
	                }
	            }
	            if (typeof warp === 'boolean' && warp) {
	                action.warp(relativeWarp ? currentTimeScale : 0, timeScale, defaultFade);
	            } else if (typeof warp === 'number') {
	                action.warp(relativeWarp ? currentTimeScale : 0, timeScale, Math.max(warp, 0));
	            } else {
	                action.timeScale = timeScale;
	            }
	            if (!action.isRunning()) {
	                if (action.time == animationClip.duration) {
	                    action.stop();
	                }
	                action.setLoop(loopMode, repetitionCount);
	                action.paused = false;
	                action.enabled = true;
	                action.clampWhenFinished = true;
	                action.play();
	            }
	            if (!this.appendedAnimations.includes(name)) {
	                this.element[$scene].appendedAnimations.push(name);
	            }
	        } catch (error) {
	            console.error(error);
	        }
	    }
	    detachAnimation(name = '', fade = true) {
	        if (this._currentGLTF == null || name === this.element.animationName) {
	            return;
	        }
	        const { animations } = this;
	        if (animations == null || animations.length === 0) {
	            return;
	        }
	        let animationClip = null;
	        const defaultFade = 1.5;
	        if (name) {
	            animationClip = this.animationsByName.get(name);
	        }
	        if (animationClip == null) {
	            return;
	        }
	        if (typeof fade === 'string') {
	            if (fade.toLowerCase().trim() === 'true') {
	                fade = true;
	            } else if (fade.toLowerCase().trim() === 'false') {
	                fade = false;
	            } else if (!isNaN(fade)) {
	                fade = parseFloat(fade);
	            } else {
	                fade = true;
	                console.warn('Invalid fade value, fade is set to true');
	            }
	        }
	        try {
	            const action = this.mixer.existingAction(animationClip) || this.mixer.clipAction(animationClip, this);
	            if (typeof fade === 'boolean' && fade) {
	                action.fadeOut(defaultFade);
	            } else if (typeof fade === 'number') {
	                action.fadeOut(Math.max(fade, 0));
	            } else {
	                action.stop();
	            }
	            const result = this.element[$scene].appendedAnimations.filter((i)=>i !== name);
	            this.element[$scene].appendedAnimations = result;
	        } catch (error) {
	            console.error(error);
	        }
	    }
	    updateAnimationLoop(name = '', loopMode = LoopRepeat, repetitionCount = Infinity) {
	        if (this._currentGLTF == null || name === this.element.animationName) {
	            return;
	        }
	        const { animations } = this;
	        if (animations == null || animations.length === 0) {
	            return;
	        }
	        let animationClip = null;
	        if (name) {
	            animationClip = this.animationsByName.get(name);
	        }
	        if (animationClip == null) {
	            return;
	        }
	        try {
	            const action = this.mixer.existingAction(animationClip) || this.mixer.clipAction(animationClip, this);
	            action.stop();
	            action.setLoop(loopMode, repetitionCount);
	            action.play();
	        } catch (error) {
	            console.error(error);
	        }
	    }
	    stopAnimation() {
	        this.currentAnimationAction = null;
	        this.mixer.stopAllAction();
	    }
	    updateAnimation(step) {
	        this.mixer.update(step);
	        this.queueShadowRender();
	    }
	    subscribeMixerEvent(event, callback) {
	        this.mixer.addEventListener(event, callback);
	    }
	 updateShadow() {
	        const shadow = this.shadow;
	        if (shadow != null) {
	            const side = this.element.arPlacement === 'wall' ? 'back' : 'bottom';
	            shadow.setScene(this, this.shadowSoftness, side);
	            shadow.needsUpdate = true;
	        }
	    }
	    renderShadow(renderer) {
	        const shadow = this.shadow;
	        if (shadow != null && shadow.needsUpdate == true) {
	            shadow.render(renderer, this);
	            shadow.needsUpdate = false;
	        }
	    }
	    queueShadowRender() {
	        if (this.shadow != null) {
	            this.shadow.needsUpdate = true;
	        }
	    }
	 setShadowIntensity(shadowIntensity) {
	        this.shadowIntensity = shadowIntensity;
	        if (this._currentGLTF == null) {
	            return;
	        }
	        this.setBakedShadowVisibility();
	        if (shadowIntensity <= 0 && this.shadow == null) {
	            return;
	        }
	        if (this.shadow == null) {
	            const side = this.element.arPlacement === 'wall' ? 'back' : 'bottom';
	            this.shadow = new Shadow(this, this.shadowSoftness, side);
	        }
	        this.shadow.setIntensity(shadowIntensity);
	    }
	 setShadowSoftness(softness) {
	        this.shadowSoftness = softness;
	        const shadow = this.shadow;
	        if (shadow != null) {
	            shadow.setSoftness(softness);
	        }
	    }
	 setShadowOffset(offset) {
	        const shadow = this.shadow;
	        if (shadow != null) {
	            shadow.setOffset(offset);
	        }
	    }
	    getHit(object = this) {
	        const hits = raycaster.intersectObject(object, true);
	        return hits.find((hit)=>hit.object.visible && !hit.object.userData.noHit);
	    }
	    hitFromController(controller, object = this) {
	        raycaster.setFromXRController(controller);
	        return this.getHit(object);
	    }
	    hitFromPoint(ndcPosition, object = this) {
	        raycaster.setFromCamera(ndcPosition, this.getCamera());
	        return this.getHit(object);
	    }
	 positionAndNormalFromPoint(ndcPosition, object = this) {
	        var _a;
	        const hit = this.hitFromPoint(ndcPosition, object);
	        if (hit == null) {
	            return null;
	        }
	        const position = hit.point;
	        const normal = hit.face != null ? hit.face.normal.clone().applyNormalMatrix(new Matrix3().getNormalMatrix(hit.object.matrixWorld)) : raycaster.ray.direction.clone().multiplyScalar(-1);
	        const uv = (_a = hit.uv) !== null && _a !== void 0 ? _a : null;
	        return {
	            position,
	            normal,
	            uv
	        };
	    }
	 surfaceFromPoint(ndcPosition, object = this) {
	        const model = this.element.model;
	        if (model == null) {
	            return null;
	        }
	        const hit = this.hitFromPoint(ndcPosition, object);
	        if (hit == null || hit.face == null) {
	            return null;
	        }
	        const node = model[$nodeFromPoint](hit);
	        const { meshes, primitives } = node.mesh.userData.associations;
	        const va = new Vector3();
	        const vb = new Vector3();
	        const vc = new Vector3();
	        const { a, b, c } = hit.face;
	        const mesh = hit.object;
	        mesh.getVertexPosition(a, va);
	        mesh.getVertexPosition(b, vb);
	        mesh.getVertexPosition(c, vc);
	        const tri = new Triangle(va, vb, vc);
	        const uvw = new Vector3();
	        tri.getBarycoord(mesh.worldToLocal(hit.point), uvw);
	        return `${meshes} ${primitives} ${a} ${b} ${c} ${uvw.x.toFixed(3)} ${uvw.y.toFixed(3)} ${uvw.z.toFixed(3)}`;
	    }
	 addHotspot(hotspot) {
	        this.target.add(hotspot);
	        this.annotationRenderer.domElement.appendChild(hotspot.element);
	        this.updateSurfaceHotspot(hotspot);
	    }
	    removeHotspot(hotspot) {
	        this.target.remove(hotspot);
	    }
	 forHotspots(func) {
	        const { children } = this.target;
	        for(let i = 0, l = children.length; i < l; i++){
	            const hotspot = children[i];
	            if (hotspot instanceof Hotspot) {
	                func(hotspot);
	            }
	        }
	    }
	 updateSurfaceHotspot(hotspot) {
	        if (hotspot.surface == null || this.element.model == null) {
	            return;
	        }
	        const nodes = parseExpressions(hotspot.surface)[0].terms;
	        if (nodes.length != 8) {
	            console.warn(hotspot.surface + ' does not have exactly 8 numbers.');
	            return;
	        }
	        const primitiveNode = this.element.model[$nodeFromIndex](nodes[0].number, nodes[1].number);
	        if (primitiveNode == null) {
	            console.warn(hotspot.surface + ' does not match a node/primitive in this glTF! Skipping this hotspot.');
	            return;
	        }
	        const numVert = primitiveNode.mesh.geometry.attributes.position.count;
	        const tri = new Vector3(nodes[2].number, nodes[3].number, nodes[4].number);
	        if (tri.x >= numVert || tri.y >= numVert || tri.z >= numVert) {
	            console.warn(hotspot.surface + ' vertex indices out of range in this glTF! Skipping this hotspot.');
	            return;
	        }
	        const bary = new Vector3(nodes[5].number, nodes[6].number, nodes[7].number);
	        hotspot.mesh = primitiveNode.mesh;
	        hotspot.tri = tri;
	        hotspot.bary = bary;
	        hotspot.updateSurface();
	    }
	 animateSurfaceHotspots() {
	        if (this.element.paused) {
	            return;
	        }
	        this.forHotspots((hotspot)=>{
	            hotspot.updateSurface();
	        });
	    }
	 updateHotspotsVisibility(viewerPosition) {
	        this.forHotspots((hotspot)=>{
	            view.copy(viewerPosition);
	            target.setFromMatrixPosition(hotspot.matrixWorld);
	            view.sub(target);
	            normalWorld.copy(hotspot.normal).transformDirection(this.target.matrixWorld);
	            if (view.dot(normalWorld) < 0) {
	                hotspot.hide();
	            } else {
	                hotspot.show();
	            }
	        });
	    }
	 orientHotspots(radians) {
	        this.forHotspots((hotspot)=>{
	            hotspot.orient(radians);
	        });
	    }
	 setHotspotsVisibility(visible) {
	        this.forHotspots((hotspot)=>{
	            hotspot.visible = visible;
	        });
	    }
	    updateSchema(src) {
	        var _a;
	        const { schemaElement, element } = this;
	        const { alt, poster, iosSrc } = element;
	        if (src != null) {
	            const encoding = [
	                {
	                    '@type': 'MediaObject',
	                    contentUrl: src,
	                    encodingFormat: ((_a = src.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'gltf' ? 'model/gltf+json' : 'model/gltf-binary'
	                }
	            ];
	            if (iosSrc) {
	                encoding.push({
	                    '@type': 'MediaObject',
	                    contentUrl: iosSrc,
	                    encodingFormat: 'model/vnd.usdz+zip'
	                });
	            }
	            const structuredData = {
	                '@context': 'http://schema.org/',
	                '@type': '3DModel',
	                image: poster !== null && poster !== void 0 ? poster : undefined,
	                name: alt !== null && alt !== void 0 ? alt : undefined,
	                encoding
	            };
	            schemaElement.textContent = JSON.stringify(structuredData);
	            document.head.appendChild(schemaElement);
	        } else if (schemaElement.parentElement != null) {
	            schemaElement.parentElement.removeChild(schemaElement);
	        }
	    }
	    constructor({ canvas, element, width, height }){
	        super();
	        this.annotationRenderer = new CSS2DRenderer();
	        this.effectRenderer = null;
	        this.schemaElement = document.createElement('script');
	        this.width = 1;
	        this.height = 1;
	        this.aspect = 1;
	        this.scaleStep = 0;
	        this.renderCount = 0;
	        this.externalRenderer = null;
	        this.appendedAnimations = [];
	        this.markedAnimations = [];
	        this.camera = new PerspectiveCamera(45, 1, 0.1, 100);
	        this.xrCamera = null;
	        this.url = null;
	        this.pivot = new Object3D();
	        this.target = new Object3D();
	        this.animationNames = [];
	        this.boundingBox = new Box3();
	        this.boundingSphere = new Sphere();
	        this.size = new Vector3();
	        this.idealAspect = 0;
	        this.framedFoVDeg = 0;
	        this.shadow = null;
	        this.shadowIntensity = 0;
	        this.shadowSoftness = 1;
	        this.bakedShadows = new Set();
	        this.exposure = 1;
	        this.toneMapping = NeutralToneMapping;
	        this.canScale = true;
	        this.isDirty = false;
	        this.goalTarget = new Vector3();
	        this.targetDamperX = new Damper();
	        this.targetDamperY = new Damper();
	        this.targetDamperZ = new Damper();
	        this._currentGLTF = null;
	        this._model = null;
	        this.cancelPendingSourceChange = null;
	        this.animationsByName = new Map();
	        this.currentAnimationAction = null;
	        this.groundedSkybox = new GroundedSkybox();
	        this.name = 'ModelScene';
	        this.element = element;
	        this.canvas = canvas;
	        this.camera = new PerspectiveCamera(45, 1, 0.1, 100);
	        this.camera.name = 'MainCamera';
	        this.add(this.pivot);
	        this.pivot.name = 'Pivot';
	        this.pivot.add(this.target);
	        this.setSize(width, height);
	        this.target.name = 'Target';
	        this.mixer = new AnimationMixer(this.target);
	        const { domElement } = this.annotationRenderer;
	        const { style } = domElement;
	        style.display = 'none';
	        style.pointerEvents = 'none';
	        style.position = 'absolute';
	        style.top = '0';
	        this.element.shadowRoot.querySelector('.default').appendChild(domElement);
	        this.schemaElement.setAttribute('type', 'application/ld+json');
	    }
	}

	class ProgressTracker extends EventTarget {
	 get ongoingActivityCount() {
	        return this.ongoingActivities.size;
	    }
	 beginActivity(reason) {
	        const activity = {
	            progress: 0,
	            completed: false
	        };
	        this.ongoingActivities.add(activity);
	        if (this.ongoingActivityCount === 1) {
	            this.announceTotalProgress(activity, 0, reason);
	        }
	        return (progress)=>{
	            let nextProgress;
	            nextProgress = Math.max(clamp(progress, 0, 1), activity.progress);
	            if (nextProgress !== activity.progress) {
	                this.announceTotalProgress(activity, nextProgress, reason);
	            }
	            return activity.progress;
	        };
	    }
	    announceTotalProgress(updatedActivity, nextProgress, reason) {
	        let progressLeft = 0;
	        let completedActivities = 0;
	        if (nextProgress == 1.0) updatedActivity.completed = true;
	        for (const activity of this.ongoingActivities){
	            const { progress } = activity;
	            progressLeft += 1.0 - progress;
	            if (activity.completed) {
	                completedActivities++;
	            }
	        }
	        const lastProgress = updatedActivity.progress;
	        updatedActivity.progress = nextProgress;
	        this.totalProgress += (nextProgress - lastProgress) * (1.0 - this.totalProgress) / progressLeft;
	        const totalProgress = completedActivities === this.ongoingActivityCount ? 1.0 : this.totalProgress;
	        this.dispatchEvent(new CustomEvent('progress', {
	            detail: {
	                totalProgress,
	                reason
	            }
	        }));
	        if (completedActivities === this.ongoingActivityCount) {
	            this.totalProgress = 0.0;
	            this.ongoingActivities.clear();
	        }
	    }
	    constructor(){
	        super(...arguments);
	        this.ongoingActivities = new Set();
	        this.totalProgress = 0;
	    }
	}

	var __decorate$4 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var _a$1, _b$1, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
	const CLEAR_MODEL_TIMEOUT_MS = 10;
	const FALLBACK_SIZE_UPDATE_THRESHOLD_MS = 50;
	const ANNOUNCE_MODEL_VISIBILITY_DEBOUNCE_THRESHOLD = 0;
	const UNSIZED_MEDIA_WIDTH = 300;
	const UNSIZED_MEDIA_HEIGHT = 150;
	const blobCanvas = document.createElement('canvas');
	const $fallbackResizeHandler = Symbol('fallbackResizeHandler');
	const $defaultAriaLabel = Symbol('defaultAriaLabel');
	const $resizeObserver = Symbol('resizeObserver');
	const $clearModelTimeout = Symbol('clearModelTimeout');
	const $onContextLost = Symbol('onContextLost');
	const $loaded = Symbol('loaded');
	const $status = Symbol('status');
	const $onFocus = Symbol('onFocus');
	const $onBlur = Symbol('onBlur');
	const $updateSize = Symbol('updateSize');
	const $intersectionObserver = Symbol('intersectionObserver');
	const $isElementInViewport = Symbol('isElementInViewport');
	const $announceModelVisibility = Symbol('announceModelVisibility');
	const $ariaLabel = Symbol('ariaLabel');
	const $altDefaulted = Symbol('altDefaulted');
	const $statusElement = Symbol('statusElement');
	const $updateStatus = Symbol('updateStatus');
	const $loadedTime = Symbol('loadedTime');
	const $updateSource = Symbol('updateSource');
	const $markLoaded = Symbol('markLoaded');
	const $container = Symbol('container');
	const $userInputElement = Symbol('input');
	const $canvas = Symbol('canvas');
	const $scene = Symbol('scene');
	const $needsRender = Symbol('needsRender');
	const $tick = Symbol('tick');
	const $onModelLoad = Symbol('onModelLoad');
	const $onResize = Symbol('onResize');
	const $renderer = Symbol('renderer');
	const $progressTracker = Symbol('progressTracker');
	const $getLoaded = Symbol('getLoaded');
	const $getModelIsVisible = Symbol('getModelIsVisible');
	const $shouldAttemptPreload = Symbol('shouldAttemptPreload');
	const toVector3D = (v)=>{
	    return {
	        x: v.x,
	        y: v.y,
	        z: v.z,
	        toString () {
	            return `${this.x}m ${this.y}m ${this.z}m`;
	        }
	    };
	};
	const toVector2D = (v)=>{
	    return {
	        u: v.x,
	        v: v.y,
	        toString () {
	            return `${this.u} ${this.v}`;
	        }
	    };
	};
	class ModelViewerElementBase extends b$1 {
	    static get is() {
	        return 'model-viewer';
	    }
	     static set modelCacheSize(value) {
	        CachingGLTFLoader[$evictionPolicy].evictionThreshold = value;
	    }
	     static get modelCacheSize() {
	        return CachingGLTFLoader[$evictionPolicy].evictionThreshold;
	    }
	     static set minimumRenderScale(value) {
	        if (value > 1) {
	            console.warn('<model-viewer> minimumRenderScale has been clamped to a maximum value of 1.');
	        }
	        if (value <= 0) {
	            console.warn('<model-viewer> minimumRenderScale has been clamped to a minimum value of 0.25.');
	        }
	        Renderer.singleton.minScale = value;
	    }
	     static get minimumRenderScale() {
	        return Renderer.singleton.minScale;
	    }
	     get loaded() {
	        return this[$getLoaded]();
	    }
	    get [(_a$1 = $isElementInViewport, _b$1 = $loaded, _c = $loadedTime, _d = $status, _e = $clearModelTimeout, _f = $fallbackResizeHandler, _g = $announceModelVisibility, _h = $resizeObserver, _j = $intersectionObserver, _k = $progressTracker, $renderer)]() {
	        return Renderer.singleton;
	    }
	     get modelIsVisible() {
	        return this[$getModelIsVisible]();
	    }
	    connectedCallback() {
	        super.connectedCallback && super.connectedCallback();
	        if (HAS_RESIZE_OBSERVER) {
	            this[$resizeObserver].observe(this);
	        } else {
	            self.addEventListener('resize', this[$fallbackResizeHandler]);
	        }
	        if (HAS_INTERSECTION_OBSERVER) {
	            this[$intersectionObserver].observe(this);
	        }
	        this.addEventListener('focus', this[$onFocus]);
	        this.addEventListener('blur', this[$onBlur]);
	        const renderer = this[$renderer];
	        renderer.addEventListener('contextlost', this[$onContextLost]);
	        renderer.registerScene(this[$scene]);
	        if (this[$clearModelTimeout] != null) {
	            self.clearTimeout(this[$clearModelTimeout]);
	            this[$clearModelTimeout] = null;
	            this.requestUpdate('src', null);
	        }
	    }
	    disconnectedCallback() {
	        super.disconnectedCallback && super.disconnectedCallback();
	        if (HAS_RESIZE_OBSERVER) {
	            this[$resizeObserver].unobserve(this);
	        } else {
	            self.removeEventListener('resize', this[$fallbackResizeHandler]);
	        }
	        if (HAS_INTERSECTION_OBSERVER) {
	            this[$intersectionObserver].unobserve(this);
	        }
	        this.removeEventListener('focus', this[$onFocus]);
	        this.removeEventListener('blur', this[$onBlur]);
	        const renderer = this[$renderer];
	        renderer.removeEventListener('contextlost', this[$onContextLost]);
	        renderer.unregisterScene(this[$scene]);
	        this[$clearModelTimeout] = self.setTimeout(()=>{
	            this[$scene].dispose();
	            this[$clearModelTimeout] = null;
	        }, CLEAR_MODEL_TIMEOUT_MS);
	    }
	    updated(changedProperties) {
	        super.updated(changedProperties);
	        if (changedProperties.has('src')) {
	            if (this.src == null) {
	                this[$loaded] = false;
	                this[$loadedTime] = 0;
	                this[$scene].reset();
	            } else if (this.src !== this[$scene].url) {
	                this[$loaded] = false;
	                this[$loadedTime] = 0;
	                this[$updateSource]();
	            }
	        }
	        if (changedProperties.has('alt')) {
	            this[$userInputElement].setAttribute('aria-label', this[$ariaLabel]);
	        }
	        if (changedProperties.has('generateSchema')) {
	            if (this.generateSchema) {
	                this[$scene].updateSchema(this.src);
	            } else {
	                this[$scene].updateSchema(null);
	            }
	        }
	    }
	     toDataURL(type, encoderOptions) {
	        return this[$renderer].displayCanvas(this[$scene]).toDataURL(type, encoderOptions);
	    }
	     async toBlob(options) {
	        const mimeType = options ? options.mimeType : undefined;
	        const qualityArgument = options ? options.qualityArgument : undefined;
	        const useIdealAspect = options ? options.idealAspect : undefined;
	        const { width, height, idealAspect, aspect } = this[$scene];
	        const { dpr, scaleFactor } = this[$renderer];
	        let outputWidth = width * scaleFactor * dpr;
	        let outputHeight = height * scaleFactor * dpr;
	        let offsetX = 0;
	        let offsetY = 0;
	        if (useIdealAspect === true) {
	            if (idealAspect > aspect) {
	                const oldHeight = outputHeight;
	                outputHeight = Math.round(outputWidth / idealAspect);
	                offsetY = (oldHeight - outputHeight) / 2;
	            } else {
	                const oldWidth = outputWidth;
	                outputWidth = Math.round(outputHeight * idealAspect);
	                offsetX = (oldWidth - outputWidth) / 2;
	            }
	        }
	        blobCanvas.width = outputWidth;
	        blobCanvas.height = outputHeight;
	        try {
	            return new Promise(async (resolve, reject)=>{
	                blobCanvas.getContext('2d').drawImage(this[$renderer].displayCanvas(this[$scene]), offsetX, offsetY, outputWidth, outputHeight, 0, 0, outputWidth, outputHeight);
	                blobCanvas.toBlob((blob)=>{
	                    if (!blob) {
	                        return reject(new Error('Unable to retrieve canvas blob'));
	                    }
	                    resolve(blob);
	                }, mimeType, qualityArgument);
	            });
	        } finally{
	            this[$updateSize]({
	                width,
	                height
	            });
	        }
	    }
	 registerEffectComposer(effectComposer) {
	        effectComposer.setRenderer(this[$renderer].threeRenderer);
	        effectComposer.setMainCamera(this[$scene].getCamera());
	        effectComposer.setMainScene(this[$scene]);
	        this[$scene].effectRenderer = effectComposer;
	    }
	 unregisterEffectComposer() {
	        this[$scene].effectRenderer = null;
	    }
	    registerRenderer(renderer) {
	        this[$scene].externalRenderer = renderer;
	    }
	    unregisterRenderer() {
	        this[$scene].externalRenderer = null;
	    }
	    get [$ariaLabel]() {
	        return this[$altDefaulted];
	    }
	    get [$altDefaulted]() {
	        return this.alt == null || this.alt === 'null' ? this[$defaultAriaLabel] : this.alt;
	    }
	    [$getLoaded]() {
	        return this[$loaded];
	    }
	    [$getModelIsVisible]() {
	        return this.loaded && this[$isElementInViewport];
	    }
	    [$shouldAttemptPreload]() {
	        return !!this.src && this[$isElementInViewport];
	    }
	 [$updateSize]({ width, height }) {
	        if (width === 0 || height === 0) {
	            return;
	        }
	        this[$container].style.width = `${width}px`;
	        this[$container].style.height = `${height}px`;
	        this[$onResize]({
	            width,
	            height
	        });
	    }
	    [$tick](time, delta) {
	        var _p;
	        (_p = this[$scene].effectRenderer) === null || _p === void 0 ? void 0 : _p.beforeRender(time, delta);
	    }
	    [$markLoaded]() {
	        if (this[$loaded]) {
	            return;
	        }
	        this[$loaded] = true;
	        this[$loadedTime] = performance.now();
	    }
	    [$needsRender]() {
	        this[$scene].queueRender();
	    }
	    [$onModelLoad]() {}
	    [$updateStatus](status) {
	        this[$status] = status;
	        const rootNode = this.getRootNode();
	        if (rootNode != null && rootNode.activeElement === this && this[$statusElement].textContent != status) {
	            this[$statusElement].textContent = status;
	        }
	    }
	    [(_l = $onFocus, _m = $onBlur, $onResize)](e) {
	        this[$scene].setSize(e.width, e.height);
	    }
	 async [(_o = $onContextLost, $updateSource)]() {
	        const scene = this[$scene];
	        if (this.loaded || !this[$shouldAttemptPreload]() || this.src === scene.url) {
	            return;
	        }
	        if (this.generateSchema) {
	            scene.updateSchema(this.src);
	        }
	        this[$updateStatus]('Loading');
	        scene.stopAnimation();
	        const updateSourceProgress = this[$progressTracker].beginActivity('model-load');
	        const source = this.src;
	        try {
	            const srcUpdated = scene.setSource(source, (progress)=>updateSourceProgress(clamp(progress, 0, 1) * 0.95));
	            const envUpdated = this[$updateEnvironment]();
	            await Promise.all([
	                srcUpdated,
	                envUpdated
	            ]);
	            this[$markLoaded]();
	            this[$onModelLoad]();
	            this.updateComplete.then(()=>{
	                this.dispatchEvent(new CustomEvent('before-render'));
	            });
	            await new Promise((resolve)=>{
	                requestAnimationFrame(()=>{
	                    requestAnimationFrame(()=>{
	                        this.dispatchEvent(new CustomEvent('load', {
	                            detail: {
	                                url: source
	                            }
	                        }));
	                        resolve();
	                    });
	                });
	            });
	        } catch (error) {
	            this.dispatchEvent(new CustomEvent('error', {
	                detail: {
	                    type: 'loadfailure',
	                    sourceError: error
	                }
	            }));
	        } finally{
	            updateSourceProgress(1.0);
	        }
	    }
	 constructor(){
	        super();
	        this.alt = null;
	        this.src = null;
	        this.withCredentials = false;
	 this.generateSchema = false;
	        this[_a$1] = false;
	        this[_b$1] = false;
	        this[_c] = 0;
	        this[_d] = '';
	        this[_e] = null;
	        this[_f] = debounce(()=>{
	            const boundingRect = this.getBoundingClientRect();
	            this[$updateSize](boundingRect);
	        }, FALLBACK_SIZE_UPDATE_THRESHOLD_MS);
	        this[_g] = debounce((oldVisibility)=>{
	            const newVisibility = this.modelIsVisible;
	            if (newVisibility !== oldVisibility) {
	                this.dispatchEvent(new CustomEvent('model-visibility', {
	                    detail: {
	                        visible: newVisibility
	                    }
	                }));
	            }
	        }, ANNOUNCE_MODEL_VISIBILITY_DEBOUNCE_THRESHOLD);
	        this[_h] = null;
	        this[_j] = null;
	        this[_k] = new ProgressTracker();
	        this[_l] = ()=>{
	            this[$statusElement].textContent = this[$status];
	        };
	        this[_m] = ()=>{
	            this[$statusElement].textContent = '';
	        };
	        this[_o] = (event)=>{
	            this.dispatchEvent(new CustomEvent('error', {
	                detail: {
	                    type: 'webglcontextlost',
	                    sourceError: event.sourceEvent
	                }
	            }));
	        };
	        this.attachShadow({
	            mode: 'open'
	        });
	        const shadowRoot = this.shadowRoot;
	        makeTemplate(shadowRoot);
	        this[$container] = shadowRoot.querySelector('.container');
	        this[$userInputElement] = shadowRoot.querySelector('.userInput');
	        this[$canvas] = shadowRoot.querySelector('canvas');
	        this[$statusElement] = shadowRoot.querySelector('#status');
	        this[$defaultAriaLabel] = this[$userInputElement].getAttribute('aria-label');
	        let width, height;
	        if (this.isConnected) {
	            const rect = this.getBoundingClientRect();
	            width = rect.width;
	            height = rect.height;
	        } else {
	            width = UNSIZED_MEDIA_WIDTH;
	            height = UNSIZED_MEDIA_HEIGHT;
	        }
	        this[$scene] = new ModelScene({
	            canvas: this[$canvas],
	            element: this,
	            width,
	            height
	        });
	        Promise.resolve().then(()=>{
	            this[$updateSize](this.getBoundingClientRect());
	        });
	        if (HAS_RESIZE_OBSERVER) {
	            this[$resizeObserver] = new ResizeObserver((entries)=>{
	                if (this[$renderer].isPresenting) {
	                    return;
	                }
	                for (let entry of entries){
	                    if (entry.target === this) {
	                        this[$updateSize](entry.contentRect);
	                    }
	                }
	            });
	        }
	        if (HAS_INTERSECTION_OBSERVER) {
	            this[$intersectionObserver] = new IntersectionObserver((entries)=>{
	                for (let entry of entries){
	                    if (entry.target === this) {
	                        const oldVisibility = this.modelIsVisible;
	                        this[$isElementInViewport] = entry.isIntersecting;
	                        this[$announceModelVisibility](oldVisibility);
	                        if (this[$isElementInViewport] && !this.loaded) {
	                            this[$updateSource]();
	                        }
	                    }
	                }
	            }, {
	                root: null,
	                rootMargin: '0px',
	                threshold: 0.00001
	            });
	        } else {
	            this[$isElementInViewport] = true;
	        }
	    }
	}
	__decorate$4([
	    n$2({
	        type: String
	    })
	], ModelViewerElementBase.prototype, "alt", void 0);
	__decorate$4([
	    n$2({
	        type: String
	    })
	], ModelViewerElementBase.prototype, "src", void 0);
	__decorate$4([
	    n$2({
	        type: Boolean,
	        attribute: 'with-credentials'
	    })
	], ModelViewerElementBase.prototype, "withCredentials", void 0);
	__decorate$4([
	    n$2({
	        type: Boolean,
	        attribute: 'generate-schema'
	    })
	], ModelViewerElementBase.prototype, "generateSchema", void 0);

	var __decorate$3 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	const MILLISECONDS_PER_SECOND = 1000.0;
	const $changeAnimation = Symbol('changeAnimation');
	const $appendAnimation = Symbol('appendAnimation');
	const $detachAnimation = Symbol('detachAnimation');
	const $paused = Symbol('paused');
	const DEFAULT_PLAY_OPTIONS = {
	    repetitions: Infinity,
	    pingpong: false
	};
	const DEFAULT_APPEND_OPTIONS = {
	    pingpong: false,
	    repetitions: null,
	    weight: 1,
	    timeScale: 1,
	    fade: false,
	    warp: false,
	    relativeWarp: true,
	    time: null
	};
	const DEFAULT_DETACH_OPTIONS = {
	    fade: true
	};
	const AnimationMixin = (ModelViewerElement)=>{
	    var _a;
	    class AnimationModelViewerElement extends ModelViewerElement {
	 get availableAnimations() {
	            if (this.loaded) {
	                return this[$scene].animationNames;
	            }
	            return [];
	        }
	        get duration() {
	            return this[$scene].duration;
	        }
	        get paused() {
	            return this[$paused];
	        }
	        get currentTime() {
	            return this[$scene].animationTime;
	        }
	        get appendedAnimations() {
	            return this[$scene].appendedAnimations;
	        }
	        set currentTime(value) {
	            this[$scene].animationTime = value;
	            this[$needsRender]();
	        }
	        get timeScale() {
	            return this[$scene].animationTimeScale;
	        }
	        set timeScale(value) {
	            this[$scene].animationTimeScale = value;
	        }
	        pause() {
	            if (this[$paused]) {
	                return;
	            }
	            this[$paused] = true;
	            this.dispatchEvent(new CustomEvent('pause'));
	        }
	        play(options) {
	            if (this.availableAnimations.length > 0) {
	                this[$paused] = false;
	                this[$changeAnimation](options);
	                this.dispatchEvent(new CustomEvent('play'));
	            }
	        }
	        appendAnimation(animationName, options) {
	            if (this.availableAnimations.length > 0) {
	                this[$paused] = false;
	                this[$appendAnimation](animationName, options);
	                this.dispatchEvent(new CustomEvent('append-animation'));
	            }
	        }
	        detachAnimation(animationName, options) {
	            if (this.availableAnimations.length > 0) {
	                this[$paused] = false;
	                this[$detachAnimation](animationName, options);
	                this.dispatchEvent(new CustomEvent('detach-animation'));
	            }
	        }
	        [(_a = $paused, $onModelLoad)]() {
	            super[$onModelLoad]();
	            this[$paused] = true;
	            if (this.animationName != null) {
	                this[$changeAnimation]();
	            }
	            if (this.autoplay) {
	                this.play();
	            }
	        }
	        [$tick](_time, delta) {
	            super[$tick](_time, delta);
	            if (this[$paused] || !this[$getModelIsVisible]() && !this[$renderer].isPresenting) {
	                return;
	            }
	            this[$scene].updateAnimation(delta / MILLISECONDS_PER_SECOND);
	            this[$needsRender]();
	        }
	        updated(changedProperties) {
	            super.updated(changedProperties);
	            if (changedProperties.has('autoplay') && this.autoplay) {
	                this.play();
	            }
	            if (changedProperties.has('animationName')) {
	                this[$changeAnimation]();
	            }
	        }
	        [$changeAnimation](options = DEFAULT_PLAY_OPTIONS) {
	            var _b;
	            const repetitions = (_b = options.repetitions) !== null && _b !== void 0 ? _b : Infinity;
	            const mode = options.pingpong ? LoopPingPong : repetitions === 1 ? LoopOnce : LoopRepeat;
	            this[$scene].playAnimation(this.animationName, this.animationCrossfadeDuration / MILLISECONDS_PER_SECOND, mode, repetitions);
	            if (this[$paused]) {
	                this[$scene].updateAnimation(0);
	                this[$needsRender]();
	            }
	        }
	        [$appendAnimation](animationName = '', options = DEFAULT_APPEND_OPTIONS) {
	            var _b;
	            const repetitions = (_b = options.repetitions) !== null && _b !== void 0 ? _b : Infinity;
	            const mode = options.pingpong ? LoopPingPong : repetitions === 1 ? LoopOnce : LoopRepeat;
	            const needsToStop = !!options.repetitions || 'pingpong' in options;
	            this[$scene].appendAnimation(animationName ? animationName : this.animationName, mode, repetitions, options.weight, options.timeScale, options.fade, options.warp, options.relativeWarp, options.time, needsToStop);
	            if (this[$paused]) {
	                this[$scene].updateAnimation(0);
	                this[$needsRender]();
	            }
	        }
	        [$detachAnimation](animationName = '', options = DEFAULT_DETACH_OPTIONS) {
	            this[$scene].detachAnimation(animationName ? animationName : this.animationName, options.fade);
	            if (this[$paused]) {
	                this[$scene].updateAnimation(0);
	                this[$needsRender]();
	            }
	        }
	        constructor(...args){
	            super(args);
	            this.autoplay = false;
	            this.animationName = undefined;
	            this.animationCrossfadeDuration = 300;
	            this[_a] = true;
	            this[$scene].subscribeMixerEvent('loop', (e)=>{
	                const count = e.action._loopCount;
	                const name = e.action._clip.name;
	                const uuid = e.action._clip.uuid;
	                const targetAnimation = this[$scene].markedAnimations.find((e)=>e.name === name);
	                if (targetAnimation) {
	                    this[$scene].updateAnimationLoop(targetAnimation.name, targetAnimation.loopMode, targetAnimation.repetitionCount);
	                    const filtredArr = this[$scene].markedAnimations.filter((e)=>e.name !== name);
	                    this[$scene].markedAnimations = filtredArr;
	                }
	                this.dispatchEvent(new CustomEvent('loop', {
	                    detail: {
	                        count,
	                        name,
	                        uuid
	                    }
	                }));
	            });
	            this[$scene].subscribeMixerEvent('finished', (e)=>{
	                if (!this[$scene].appendedAnimations.includes(e.action._clip.name)) {
	                    this[$paused] = true;
	                } else {
	                    const filterdList = this[$scene].appendedAnimations.filter((i)=>i !== e.action._clip.name);
	                    this[$scene].appendedAnimations = filterdList;
	                }
	                this.dispatchEvent(new CustomEvent('finished'));
	            });
	        }
	    }
	    __decorate$3([
	        n$2({
	            type: Boolean
	        })
	    ], AnimationModelViewerElement.prototype, "autoplay", void 0);
	    __decorate$3([
	        n$2({
	            type: String,
	            attribute: 'animation-name'
	        })
	    ], AnimationModelViewerElement.prototype, "animationName", void 0);
	    __decorate$3([
	        n$2({
	            type: Number,
	            attribute: 'animation-crossfade-duration'
	        })
	    ], AnimationModelViewerElement.prototype, "animationCrossfadeDuration", void 0);
	    return AnimationModelViewerElement;
	};

	const $hotspotMap = Symbol('hotspotMap');
	const $mutationCallback = Symbol('mutationCallback');
	const $observer = Symbol('observer');
	const $addHotspot = Symbol('addHotspot');
	const $removeHotspot = Symbol('removeHotspot');
	const worldToModel = new Matrix4();
	 const AnnotationMixin = (ModelViewerElement)=>{
	    var _a, _b, _c;
	    class AnnotationModelViewerElement extends ModelViewerElement {
	        connectedCallback() {
	            super.connectedCallback();
	            for(let i = 0; i < this.children.length; ++i){
	                this[$addHotspot](this.children[i]);
	            }
	            const { ShadyDOM } = self;
	            if (ShadyDOM == null) {
	                this[$observer].observe(this, {
	                    childList: true
	                });
	            } else {
	                this[$observer] = ShadyDOM.observeChildren(this, this[$mutationCallback]);
	            }
	        }
	        disconnectedCallback() {
	            super.disconnectedCallback();
	            const { ShadyDOM } = self;
	            if (ShadyDOM == null) {
	                this[$observer].disconnect();
	            } else {
	                ShadyDOM.unobserveChildren(this[$observer]);
	            }
	        }
	        [(_a = $hotspotMap, _b = $mutationCallback, _c = $observer, $onModelLoad)]() {
	            super[$onModelLoad]();
	            const scene = this[$scene];
	            scene.forHotspots((hotspot)=>{
	                scene.updateSurfaceHotspot(hotspot);
	            });
	        }
	        [$tick](time, delta) {
	            super[$tick](time, delta);
	            const scene = this[$scene];
	            const { annotationRenderer } = scene;
	            const camera = scene.getCamera();
	            if (scene.shouldRender()) {
	                scene.animateSurfaceHotspots();
	                scene.updateHotspotsVisibility(camera.position);
	                annotationRenderer.domElement.style.display = '';
	                annotationRenderer.render(scene, camera);
	            }
	        }
	 updateHotspot(config) {
	            const hotspot = this[$hotspotMap].get(config.name);
	            if (hotspot == null) {
	                return;
	            }
	            hotspot.updatePosition(config.position);
	            hotspot.updateNormal(config.normal);
	            hotspot.surface = config.surface;
	            this[$scene].updateSurfaceHotspot(hotspot);
	            this[$needsRender]();
	        }
	 queryHotspot(name) {
	            const hotspot = this[$hotspotMap].get(name);
	            if (hotspot == null) {
	                return null;
	            }
	            const position = toVector3D(hotspot.position);
	            const normal = toVector3D(hotspot.normal);
	            const facingCamera = hotspot.facingCamera;
	            const scene = this[$scene];
	            const camera = scene.getCamera();
	            const vector = new Vector3();
	            vector.setFromMatrixPosition(hotspot.matrixWorld);
	            vector.project(camera);
	            const widthHalf = scene.width / 2;
	            const heightHalf = scene.height / 2;
	            vector.x = vector.x * widthHalf + widthHalf;
	            vector.y = -(vector.y * heightHalf) + heightHalf;
	            const canvasPosition = toVector3D(new Vector3(vector.x, vector.y, vector.z));
	            if (!Number.isFinite(canvasPosition.x) || !Number.isFinite(canvasPosition.y)) {
	                return null;
	            }
	            return {
	                position,
	                normal,
	                canvasPosition,
	                facingCamera
	            };
	        }
	 positionAndNormalFromPoint(pixelX, pixelY) {
	            const scene = this[$scene];
	            const ndcPosition = scene.getNDC(pixelX, pixelY);
	            const hit = scene.positionAndNormalFromPoint(ndcPosition);
	            if (hit == null) {
	                return null;
	            }
	            worldToModel.copy(scene.target.matrixWorld).invert();
	            const position = toVector3D(hit.position.applyMatrix4(worldToModel));
	            const normal = toVector3D(hit.normal.transformDirection(worldToModel));
	            let uv = null;
	            if (hit.uv != null) {
	                uv = toVector2D(hit.uv);
	            }
	            return {
	                position: position,
	                normal: normal,
	                uv: uv
	            };
	        }
	 surfaceFromPoint(pixelX, pixelY) {
	            const scene = this[$scene];
	            const ndcPosition = scene.getNDC(pixelX, pixelY);
	            return scene.surfaceFromPoint(ndcPosition);
	        }
	        [$addHotspot](node) {
	            if (!(node instanceof HTMLElement && node.slot.indexOf('hotspot') === 0)) {
	                return;
	            }
	            let hotspot = this[$hotspotMap].get(node.slot);
	            if (hotspot != null) {
	                hotspot.increment();
	            } else {
	                hotspot = new Hotspot({
	                    name: node.slot,
	                    position: node.dataset.position,
	                    normal: node.dataset.normal,
	                    surface: node.dataset.surface
	                });
	                this[$hotspotMap].set(node.slot, hotspot);
	                this[$scene].addHotspot(hotspot);
	            }
	            this[$scene].queueRender();
	        }
	        [$removeHotspot](node) {
	            if (!(node instanceof HTMLElement)) {
	                return;
	            }
	            const hotspot = this[$hotspotMap].get(node.slot);
	            if (!hotspot) {
	                return;
	            }
	            if (hotspot.decrement()) {
	                this[$scene].removeHotspot(hotspot);
	                this[$hotspotMap].delete(node.slot);
	            }
	            this[$scene].queueRender();
	        }
	        constructor(){
	            super(...arguments);
	            this[_a] = new Map();
	            this[_b] = (mutations)=>{
	                mutations.forEach((mutation)=>{
	                    if (!(mutation instanceof MutationRecord) || mutation.type === 'childList') {
	                        mutation.addedNodes.forEach((node)=>{
	                            this[$addHotspot](node);
	                        });
	                        mutation.removedNodes.forEach((node)=>{
	                            this[$removeHotspot](node);
	                        });
	                        this[$needsRender]();
	                    }
	                });
	            };
	            this[_c] = new MutationObserver(this[$mutationCallback]);
	        }
	    }
	    return AnnotationModelViewerElement;
	};

	/*!
	fflate - fast JavaScript compression/decompression
	<https://101arrowz.github.io/fflate>
	Licensed under MIT. https://github.com/101arrowz/fflate/blob/master/LICENSE
	version 0.8.2
	*/ // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
	// https://tools.ietf.org/html/rfc1951
	// You may also wish to take a look at the guide I made about this program:
	// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
	// Some of the following code is similar to that of UZIP.js:
	// https://github.com/photopea/UZIP.js
	// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
	// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
	// is better for memory in most engines (I *think*).
	// aliases for shorter compressed code (most minifers don't do this)
	var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
	// fixed length extra bits
	var fleb = new u8([
	    0,
	    0,
	    0,
	    0,
	    0,
	    0,
	    0,
	    0,
	    1,
	    1,
	    1,
	    1,
	    2,
	    2,
	    2,
	    2,
	    3,
	    3,
	    3,
	    3,
	    4,
	    4,
	    4,
	    4,
	    5,
	    5,
	    5,
	    5,
	    0,
	    /* unused */ 0,
	    0,
	    /* impossible */ 0
	]);
	// fixed distance extra bits
	var fdeb = new u8([
	    0,
	    0,
	    0,
	    0,
	    1,
	    1,
	    2,
	    2,
	    3,
	    3,
	    4,
	    4,
	    5,
	    5,
	    6,
	    6,
	    7,
	    7,
	    8,
	    8,
	    9,
	    9,
	    10,
	    10,
	    11,
	    11,
	    12,
	    12,
	    13,
	    13,
	    /* unused */ 0,
	    0
	]);
	// code length index map
	var clim = new u8([
	    16,
	    17,
	    18,
	    0,
	    8,
	    7,
	    9,
	    6,
	    10,
	    5,
	    11,
	    4,
	    12,
	    3,
	    13,
	    2,
	    14,
	    1,
	    15
	]);
	// get base, reverse index map from extra bits
	var freb = function(eb, start) {
	    var b = new u16(31);
	    for(var i = 0; i < 31; ++i){
	        b[i] = start += 1 << eb[i - 1];
	    }
	    // numbers here are at max 18 bits
	    var r = new i32(b[30]);
	    for(var i = 1; i < 30; ++i){
	        for(var j = b[i]; j < b[i + 1]; ++j){
	            r[j] = j - b[i] << 5 | i;
	        }
	    }
	    return {
	        b: b,
	        r: r
	    };
	};
	var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
	// we can ignore the fact that the other numbers are wrong; they never happen anyway
	fl[28] = 258, revfl[258] = 28;
	var _b = freb(fdeb, 0), revfd = _b.r;
	// map of value to reverse (assuming 16 bits)
	var rev = new u16(32768);
	for(var i = 0; i < 32768; ++i){
	    // reverse table algorithm from SO
	    var x = (i & 0xAAAA) >> 1 | (i & 0x5555) << 1;
	    x = (x & 0xCCCC) >> 2 | (x & 0x3333) << 2;
	    x = (x & 0xF0F0) >> 4 | (x & 0x0F0F) << 4;
	    rev[i] = ((x & 0xFF00) >> 8 | (x & 0x00FF) << 8) >> 1;
	}
	// create huffman tree from u8 "map": index -> code length for code index
	// mb (max bits) must be at most 15
	// TODO: optimize/split up?
	var hMap = function(cd, mb, r) {
	    var s = cd.length;
	    // index
	    var i = 0;
	    // u16 "map": index -> # of codes with bit length = index
	    var l = new u16(mb);
	    // length of cd must be 288 (total # of codes)
	    for(; i < s; ++i){
	        if (cd[i]) ++l[cd[i] - 1];
	    }
	    // u16 "map": index -> minimum code for bit length = index
	    var le = new u16(mb);
	    for(i = 1; i < mb; ++i){
	        le[i] = le[i - 1] + l[i - 1] << 1;
	    }
	    var co;
	    if (r) {
	        // u16 "map": index -> number of actual bits, symbol for code
	        co = new u16(1 << mb);
	        // bits to remove for reverser
	        var rvb = 15 - mb;
	        for(i = 0; i < s; ++i){
	            // ignore 0 lengths
	            if (cd[i]) {
	                // num encoding both symbol and bits read
	                var sv = i << 4 | cd[i];
	                // free bits
	                var r_1 = mb - cd[i];
	                // start value
	                var v = le[cd[i] - 1]++ << r_1;
	                // m is end value
	                for(var m = v | (1 << r_1) - 1; v <= m; ++v){
	                    // every 16 bit value starting with the code yields the same result
	                    co[rev[v] >> rvb] = sv;
	                }
	            }
	        }
	    } else {
	        co = new u16(s);
	        for(i = 0; i < s; ++i){
	            if (cd[i]) {
	                co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
	            }
	        }
	    }
	    return co;
	};
	// fixed length tree
	var flt = new u8(288);
	for(var i = 0; i < 144; ++i)flt[i] = 8;
	for(var i = 144; i < 256; ++i)flt[i] = 9;
	for(var i = 256; i < 280; ++i)flt[i] = 7;
	for(var i = 280; i < 288; ++i)flt[i] = 8;
	// fixed distance tree
	var fdt = new u8(32);
	for(var i = 0; i < 32; ++i)fdt[i] = 5;
	// fixed length map
	var flm = /*#__PURE__*/ hMap(flt, 9, 0);
	// fixed distance map
	var fdm = /*#__PURE__*/ hMap(fdt, 5, 0);
	// get end of byte
	var shft = function(p) {
	    return (p + 7) / 8 | 0;
	};
	// typed array slice - allows garbage collector to free original reference,
	// while being more compatible than .slice
	var slc = function(v, s, e) {
	    if (e == null || e > v.length) e = v.length;
	    // can't use .constructor in case user-supplied
	    return new u8(v.subarray(s, e));
	};
	// error codes
	var ec = [
	    'unexpected EOF',
	    'invalid block type',
	    'invalid length/literal',
	    'invalid distance',
	    'stream finished',
	    'no stream handler',
	    ,
	    'no callback',
	    'invalid UTF-8 data',
	    'extra field too long',
	    'date not in range 1980-2099',
	    'filename too long',
	    'stream finishing',
	    'invalid zip data'
	];
	var err = function(ind, msg, nt) {
	    var e = new Error(msg || ec[ind]);
	    e.code = ind;
	    if (Error.captureStackTrace) Error.captureStackTrace(e, err);
	    if (!nt) throw e;
	    return e;
	};
	// starting at p, write the minimum number of bits that can hold v to d
	var wbits = function(d, p, v) {
	    v <<= p & 7;
	    var o = p / 8 | 0;
	    d[o] |= v;
	    d[o + 1] |= v >> 8;
	};
	// starting at p, write the minimum number of bits (>8) that can hold v to d
	var wbits16 = function(d, p, v) {
	    v <<= p & 7;
	    var o = p / 8 | 0;
	    d[o] |= v;
	    d[o + 1] |= v >> 8;
	    d[o + 2] |= v >> 16;
	};
	// creates code lengths from a frequency table
	var hTree = function(d, mb) {
	    // Need extra info to make a tree
	    var t = [];
	    for(var i = 0; i < d.length; ++i){
	        if (d[i]) t.push({
	            s: i,
	            f: d[i]
	        });
	    }
	    var s = t.length;
	    var t2 = t.slice();
	    if (!s) return {
	        t: et,
	        l: 0
	    };
	    if (s == 1) {
	        var v = new u8(t[0].s + 1);
	        v[t[0].s] = 1;
	        return {
	            t: v,
	            l: 1
	        };
	    }
	    t.sort(function(a, b) {
	        return a.f - b.f;
	    });
	    // after i2 reaches last ind, will be stopped
	    // freq must be greater than largest possible number of symbols
	    t.push({
	        s: -1,
	        f: 25001
	    });
	    var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
	    t[0] = {
	        s: -1,
	        f: l.f + r.f,
	        l: l,
	        r: r
	    };
	    // efficient algorithm from UZIP.js
	    // i0 is lookbehind, i2 is lookahead - after processing two low-freq
	    // symbols that combined have high freq, will start processing i2 (high-freq,
	    // non-composite) symbols instead
	    // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/
	    while(i1 != s - 1){
	        l = t[t[i0].f < t[i2].f ? i0++ : i2++];
	        r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
	        t[i1++] = {
	            s: -1,
	            f: l.f + r.f,
	            l: l,
	            r: r
	        };
	    }
	    var maxSym = t2[0].s;
	    for(var i = 1; i < s; ++i){
	        if (t2[i].s > maxSym) maxSym = t2[i].s;
	    }
	    // code lengths
	    var tr = new u16(maxSym + 1);
	    // max bits in tree
	    var mbt = ln(t[i1 - 1], tr, 0);
	    if (mbt > mb) {
	        // more algorithms from UZIP.js
	        // TODO: find out how this code works (debt)
	        //  ind    debt
	        var i = 0, dt = 0;
	        //    left            cost
	        var lft = mbt - mb, cst = 1 << lft;
	        t2.sort(function(a, b) {
	            return tr[b.s] - tr[a.s] || a.f - b.f;
	        });
	        for(; i < s; ++i){
	            var i2_1 = t2[i].s;
	            if (tr[i2_1] > mb) {
	                dt += cst - (1 << mbt - tr[i2_1]);
	                tr[i2_1] = mb;
	            } else break;
	        }
	        dt >>= lft;
	        while(dt > 0){
	            var i2_2 = t2[i].s;
	            if (tr[i2_2] < mb) dt -= 1 << mb - tr[i2_2]++ - 1;
	            else ++i;
	        }
	        for(; i >= 0 && dt; --i){
	            var i2_3 = t2[i].s;
	            if (tr[i2_3] == mb) {
	                --tr[i2_3];
	                ++dt;
	            }
	        }
	        mbt = mb;
	    }
	    return {
	        t: new u8(tr),
	        l: mbt
	    };
	};
	// get the max length and assign length codes
	var ln = function(n, l, d) {
	    return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
	};
	// length codes generation
	var lc = function(c) {
	    var s = c.length;
	    // Note that the semicolon was intentional
	    while(s && !c[--s]);
	    var cl = new u16(++s);
	    //  ind      num         streak
	    var cli = 0, cln = c[0], cls = 1;
	    var w = function(v) {
	        cl[cli++] = v;
	    };
	    for(var i = 1; i <= s; ++i){
	        if (c[i] == cln && i != s) ++cls;
	        else {
	            if (!cln && cls > 2) {
	                for(; cls > 138; cls -= 138)w(32754);
	                if (cls > 2) {
	                    w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
	                    cls = 0;
	                }
	            } else if (cls > 3) {
	                w(cln), --cls;
	                for(; cls > 6; cls -= 6)w(8304);
	                if (cls > 2) w(cls - 3 << 5 | 8208), cls = 0;
	            }
	            while(cls--)w(cln);
	            cls = 1;
	            cln = c[i];
	        }
	    }
	    return {
	        c: cl.subarray(0, cli),
	        n: s
	    };
	};
	// calculate the length of output from tree, code lengths
	var clen = function(cf, cl) {
	    var l = 0;
	    for(var i = 0; i < cl.length; ++i)l += cf[i] * cl[i];
	    return l;
	};
	// writes a fixed block
	// returns the new bit pos
	var wfblk = function(out, pos, dat) {
	    // no need to write 00 as type: TypedArray defaults to 0
	    var s = dat.length;
	    var o = shft(pos + 2);
	    out[o] = s & 255;
	    out[o + 1] = s >> 8;
	    out[o + 2] = out[o] ^ 255;
	    out[o + 3] = out[o + 1] ^ 255;
	    for(var i = 0; i < s; ++i)out[o + i + 4] = dat[i];
	    return (o + 4 + s) * 8;
	};
	// writes a block
	var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
	    wbits(out, p++, final);
	    ++lf[256];
	    var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l;
	    var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l;
	    var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
	    var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
	    var lcfreq = new u16(19);
	    for(var i = 0; i < lclt.length; ++i)++lcfreq[lclt[i] & 31];
	    for(var i = 0; i < lcdt.length; ++i)++lcfreq[lcdt[i] & 31];
	    var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
	    var nlcc = 19;
	    for(; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc);
	    var flen = bl + 5 << 3;
	    var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
	    var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
	    if (bs >= 0 && flen <= ftlen && flen <= dtlen) return wfblk(out, p, dat.subarray(bs, bs + bl));
	    var lm, ll, dm, dl;
	    wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
	    if (dtlen < ftlen) {
	        lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
	        var llm = hMap(lct, mlcb, 0);
	        wbits(out, p, nlc - 257);
	        wbits(out, p + 5, ndc - 1);
	        wbits(out, p + 10, nlcc - 4);
	        p += 14;
	        for(var i = 0; i < nlcc; ++i)wbits(out, p + 3 * i, lct[clim[i]]);
	        p += 3 * nlcc;
	        var lcts = [
	            lclt,
	            lcdt
	        ];
	        for(var it = 0; it < 2; ++it){
	            var clct = lcts[it];
	            for(var i = 0; i < clct.length; ++i){
	                var len = clct[i] & 31;
	                wbits(out, p, llm[len]), p += lct[len];
	                if (len > 15) wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
	            }
	        }
	    } else {
	        lm = flm, ll = flt, dm = fdm, dl = fdt;
	    }
	    for(var i = 0; i < li; ++i){
	        var sym = syms[i];
	        if (sym > 255) {
	            var len = sym >> 18 & 31;
	            wbits16(out, p, lm[len + 257]), p += ll[len + 257];
	            if (len > 7) wbits(out, p, sym >> 23 & 31), p += fleb[len];
	            var dst = sym & 31;
	            wbits16(out, p, dm[dst]), p += dl[dst];
	            if (dst > 3) wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
	        } else {
	            wbits16(out, p, lm[sym]), p += ll[sym];
	        }
	    }
	    wbits16(out, p, lm[256]);
	    return p + ll[256];
	};
	// deflate options (nice << 13) | chain
	var deo = /*#__PURE__*/ new i32([
	    65540,
	    131080,
	    131088,
	    131104,
	    262176,
	    1048704,
	    1048832,
	    2114560,
	    2117632
	]);
	// empty
	var et = /*#__PURE__*/ new u8(0);
	// compresses data into a raw DEFLATE buffer
	var dflt = function(dat, lvl, plvl, pre, post, st) {
	    var s = st.z || dat.length;
	    var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
	    // writing to this writes to the output buffer
	    var w = o.subarray(pre, o.length - post);
	    var lst = st.l;
	    var pos = (st.r || 0) & 7;
	    if (lvl) {
	        if (pos) w[0] = st.r >> 3;
	        var opt = deo[lvl - 1];
	        var n = opt >> 13, c = opt & 8191;
	        var msk_1 = (1 << plvl) - 1;
	        //    prev 2-byte val map    curr 2-byte val map
	        var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
	        var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
	        var hsh = function(i) {
	            return (dat[i] ^ dat[i + 1] << bs1_1 ^ dat[i + 2] << bs2_1) & msk_1;
	        };
	        // 24576 is an arbitrary number of maximum symbols per block
	        // 424 buffer for last block
	        var syms = new i32(25000);
	        // length/literal freq   distance freq
	        var lf = new u16(288), df = new u16(32);
	        //  l/lcnt  exbits  index          l/lind  waitdx          blkpos
	        var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
	        for(; i + 2 < s; ++i){
	            // hash value
	            var hv = hsh(i);
	            // index mod 32768    previous index mod
	            var imod = i & 32767, pimod = head[hv];
	            prev[imod] = pimod;
	            head[hv] = imod;
	            // We always should modify head and prev, but only add symbols if
	            // this data is not yet processed ("wait" for wait index)
	            if (wi <= i) {
	                // bytes remaining
	                var rem = s - i;
	                if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
	                    pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
	                    li = lc_1 = eb = 0, bs = i;
	                    for(var j = 0; j < 286; ++j)lf[j] = 0;
	                    for(var j = 0; j < 30; ++j)df[j] = 0;
	                }
	                //  len    dist   chain
	                var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
	                if (rem > 2 && hv == hsh(i - dif)) {
	                    var maxn = Math.min(n, rem) - 1;
	                    var maxd = Math.min(32767, i);
	                    // max possible length
	                    // not capped at dif because decompressors implement "rolling" index population
	                    var ml = Math.min(258, rem);
	                    while(dif <= maxd && --ch_1 && imod != pimod){
	                        if (dat[i + l] == dat[i + l - dif]) {
	                            var nl = 0;
	                            for(; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl);
	                            if (nl > l) {
	                                l = nl, d = dif;
	                                // break out early when we reach "nice" (we are satisfied enough)
	                                if (nl > maxn) break;
	                                // now, find the rarest 2-byte sequence within this
	                                // length of literals and search for that instead.
	                                // Much faster than just using the start
	                                var mmd = Math.min(dif, nl - 2);
	                                var md = 0;
	                                for(var j = 0; j < mmd; ++j){
	                                    var ti = i - dif + j & 32767;
	                                    var pti = prev[ti];
	                                    var cd = ti - pti & 32767;
	                                    if (cd > md) md = cd, pimod = ti;
	                                }
	                            }
	                        }
	                        // check the previous match
	                        imod = pimod, pimod = prev[imod];
	                        dif += imod - pimod & 32767;
	                    }
	                }
	                // d will be nonzero only when a match was found
	                if (d) {
	                    // store both dist and len data in one int32
	                    // Make sure this is recognized as a len/dist with 28th bit (2^28)
	                    syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
	                    var lin = revfl[l] & 31, din = revfd[d] & 31;
	                    eb += fleb[lin] + fdeb[din];
	                    ++lf[257 + lin];
	                    ++df[din];
	                    wi = i + l;
	                    ++lc_1;
	                } else {
	                    syms[li++] = dat[i];
	                    ++lf[dat[i]];
	                }
	            }
	        }
	        for(i = Math.max(i, wi); i < s; ++i){
	            syms[li++] = dat[i];
	            ++lf[dat[i]];
	        }
	        pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
	        if (!lst) {
	            st.r = pos & 7 | w[pos / 8 | 0] << 3;
	            // shft(pos) now 1 less if pos & 7 != 0
	            pos -= 7;
	            st.h = head, st.p = prev, st.i = i, st.w = wi;
	        }
	    } else {
	        for(var i = st.w || 0; i < s + lst; i += 65535){
	            // end
	            var e = i + 65535;
	            if (e >= s) {
	                // write final block
	                w[pos / 8 | 0] = lst;
	                e = s;
	            }
	            pos = wfblk(w, pos + 1, dat.subarray(i, e));
	        }
	        st.i = s;
	    }
	    return slc(o, 0, pre + shft(pos) + post);
	};
	// CRC32 table
	var crct = /*#__PURE__*/ function() {
	    var t = new Int32Array(256);
	    for(var i = 0; i < 256; ++i){
	        var c = i, k = 9;
	        while(--k)c = (c & 1 && -306674912) ^ c >>> 1;
	        t[i] = c;
	    }
	    return t;
	}();
	// CRC32
	var crc = function() {
	    var c = -1;
	    return {
	        p: function(d) {
	            // closures have awful performance
	            var cr = c;
	            for(var i = 0; i < d.length; ++i)cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
	            c = cr;
	        },
	        d: function() {
	            return ~c;
	        }
	    };
	};
	// deflate with opts
	var dopt = function(dat, opt, pre, post, st) {
	    if (!st) {
	        st = {
	            l: 1
	        };
	        if (opt.dictionary) {
	            var dict = opt.dictionary.subarray(-32768);
	            var newDat = new u8(dict.length + dat.length);
	            newDat.set(dict);
	            newDat.set(dat, dict.length);
	            dat = newDat;
	            st.w = dict.length;
	        }
	    }
	    return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
	};
	// Walmart object spread
	var mrg = function(a, b) {
	    var o = {};
	    for(var k in a)o[k] = a[k];
	    for(var k in b)o[k] = b[k];
	    return o;
	};
	// write bytes
	var wbytes = function(d, b, v) {
	    for(; v; ++b)d[b] = v, v >>>= 8;
	};
	/**
	 * Compresses data with DEFLATE without any wrapper
	 * @param data The data to compress
	 * @param opts The compression options
	 * @returns The deflated version of the data
	 */ function deflateSync(data, opts) {
	    return dopt(data, opts || {}, 0, 0);
	}
	// flatten a directory structure
	var fltn = function(d, p, t, o) {
	    for(var k in d){
	        var val = d[k], n = p + k, op = o;
	        if (Array.isArray(val)) op = mrg(o, val[1]), val = val[0];
	        if (val instanceof u8) t[n] = [
	            val,
	            op
	        ];
	        else {
	            t[n += '/'] = [
	                new u8(0),
	                op
	            ];
	            fltn(val, n, t, o);
	        }
	    }
	};
	// text encoder
	var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder();
	// text decoder
	var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
	// text decoder stream
	var tds = 0;
	try {
	    td.decode(et, {
	        stream: true
	    });
	    tds = 1;
	} catch (e) {}
	/**
	 * Converts a string into a Uint8Array for use with compression/decompression methods
	 * @param str The string to encode
	 * @param latin1 Whether or not to interpret the data as Latin-1. This should
	 *               not need to be true unless decoding a binary string.
	 * @returns The string encoded in UTF-8/Latin-1 binary
	 */ function strToU8(str, latin1) {
	    var i; 
	    if (te) return te.encode(str);
	    var l = str.length;
	    var ar = new u8(str.length + (str.length >> 1));
	    var ai = 0;
	    var w = function(v) {
	        ar[ai++] = v;
	    };
	    for(var i = 0; i < l; ++i){
	        if (ai + 5 > ar.length) {
	            var n = new u8(ai + 8 + (l - i << 1));
	            n.set(ar);
	            ar = n;
	        }
	        var c = str.charCodeAt(i);
	        if (c < 128 || latin1) w(c);
	        else if (c < 2048) w(192 | c >> 6), w(128 | c & 63);
	        else if (c > 55295 && c < 57344) c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
	        else w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
	    }
	    return slc(ar, 0, ai);
	}
	// extra field length
	var exfl = function(ex) {
	    var le = 0;
	    if (ex) {
	        for(var k in ex){
	            var l = ex[k].length;
	            if (l > 65535) err(9);
	            le += l + 4;
	        }
	    }
	    return le;
	};
	// write zip header
	var wzh = function(d, b, f, fn, u, c, ce, co) {
	    var fl = fn.length, ex = f.extra, col = co && co.length;
	    var exl = exfl(ex);
	    wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;
	    if (ce != null) d[b++] = 20, d[b++] = f.os;
	    d[b] = 20, b += 2; // spec compliance? what's that?
	    d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
	    d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
	    var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
	    if (y < 0 || y > 119) err(10);
	    wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
	    if (c != -1) {
	        wbytes(d, b, f.crc);
	        wbytes(d, b + 4, c < 0 ? -c - 2 : c);
	        wbytes(d, b + 8, f.size);
	    }
	    wbytes(d, b + 12, fl);
	    wbytes(d, b + 14, exl), b += 16;
	    if (ce != null) {
	        wbytes(d, b, col);
	        wbytes(d, b + 6, f.attrs);
	        wbytes(d, b + 10, ce), b += 14;
	    }
	    d.set(fn, b);
	    b += fl;
	    if (exl) {
	        for(var k in ex){
	            var exf = ex[k], l = exf.length;
	            wbytes(d, b, +k);
	            wbytes(d, b + 2, l);
	            d.set(exf, b + 4), b += 4 + l;
	        }
	    }
	    if (col) d.set(co, b), b += col;
	    return b;
	};
	// write zip footer (end of central directory)
	var wzf = function(o, b, c, d, e) {
	    wbytes(o, b, 0x6054B50); // skip disk
	    wbytes(o, b + 8, c);
	    wbytes(o, b + 10, c);
	    wbytes(o, b + 12, d);
	    wbytes(o, b + 16, e);
	};
	/**
	 * Synchronously creates a ZIP file. Prefer using `zip` for better performance
	 * with more than one file.
	 * @param data The directory structure for the ZIP archive
	 * @param opts The main options, merged with per-file options
	 * @returns The generated ZIP archive
	 */ function zipSync(data, opts) {
	    if (!opts) opts = {};
	    var r = {};
	    var files = [];
	    fltn(data, '', r, opts);
	    var o = 0;
	    var tot = 0;
	    for(var fn in r){
	        var _a = r[fn], file = _a[0], p = _a[1];
	        var compression = p.level == 0 ? 0 : 8;
	        var f = strToU8(fn), s = f.length;
	        var com = p.comment, m = com && strToU8(com), ms = m && m.length;
	        var exl = exfl(p.extra);
	        if (s > 65535) err(11);
	        var d = compression ? deflateSync(file, p) : file, l = d.length;
	        var c = crc();
	        c.p(file);
	        files.push(mrg(p, {
	            size: file.length,
	            crc: c.d(),
	            c: d,
	            f: f,
	            m: m,
	            u: s != fn.length || m && com.length != ms,
	            o: o,
	            compression: compression
	        }));
	        o += 30 + s + exl + l;
	        tot += 76 + 2 * (s + exl) + (ms || 0) + l;
	    }
	    var out = new u8(tot + 22), oe = o, cdl = tot - o;
	    for(var i = 0; i < files.length; ++i){
	        var f = files[i];
	        wzh(out, f.o, f, f.f, f.u, f.c.length);
	        var badd = 30 + f.f.length + exfl(f.extra);
	        out.set(f.c, f.o + badd);
	        wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
	    }
	    wzf(out, o, files.length, cdl, oe);
	    return out;
	}

	class USDZExporter {
	    setTextureUtils(utils) {
	        this.textureUtils = utils;
	    }
	    parse(scene, onDone, onError, options) {
	        this.parseAsync(scene, options).then(onDone).catch(onError);
	    }
	    async parseAsync(scene, options = {}) {
	        options = Object.assign({
	            ar: {
	                anchoring: {
	                    type: 'plane'
	                },
	                planeAnchoring: {
	                    alignment: 'horizontal'
	                }
	            },
	            includeAnchoringProperties: true,
	            quickLookCompatible: false,
	            maxTextureSize: 1024
	        }, options);
	        const files = {};
	        const modelFileName = 'model.usda';
	        // model file should be first in USDZ archive so we init it here
	        files[modelFileName] = null;
	        let output = buildHeader();
	        output += buildSceneStart(options);
	        const materials = {};
	        const textures = {};
	        scene.traverseVisible((object)=>{
	            if (object.isMesh) {
	                const geometry = object.geometry;
	                const material = object.material;
	                if (material.isMeshStandardMaterial) {
	                    const geometryFileName = 'geometries/Geometry_' + geometry.id + '.usda';
	                    if (!(geometryFileName in files)) {
	                        const meshObject = buildMeshObject(geometry);
	                        files[geometryFileName] = buildUSDFileAsString(meshObject);
	                    }
	                    if (!(material.uuid in materials)) {
	                        materials[material.uuid] = material;
	                    }
	                    output += buildXform(object, geometry, material);
	                } else {
	                    console.warn('THREE.USDZExporter: Unsupported material type (USDZ only supports MeshStandardMaterial)', object);
	                }
	            } else if (object.isCamera) {
	                output += buildCamera(object);
	            }
	        });
	        output += buildSceneEnd();
	        output += buildMaterials(materials, textures, options.quickLookCompatible);
	        files[modelFileName] = strToU8(output);
	        output = null;
	        for(const id in textures){
	            let texture = textures[id];
	            if (texture.isCompressedTexture === true) {
	                if (this.textureUtils === null) {
	                    throw new Error('THREE.USDZExporter: setTextureUtils() must be called to process compressed textures.');
	                } else {
	                    texture = await this.textureUtils.decompress(texture);
	                }
	            }
	            const canvas = imageToCanvas(texture.image, texture.flipY, options.maxTextureSize);
	            const blob = await new Promise((resolve)=>canvas.toBlob(resolve, 'image/png', 1));
	            files[`textures/Texture_${id}.png`] = new Uint8Array(await blob.arrayBuffer());
	        }
	        // 64 byte alignment
	        // https://github.com/101arrowz/fflate/issues/39#issuecomment-777263109
	        let offset = 0;
	        for(const filename in files){
	            const file = files[filename];
	            const headerSize = 34 + filename.length;
	            offset += headerSize;
	            const offsetMod64 = offset & 63;
	            if (offsetMod64 !== 4) {
	                const padLength = 64 - offsetMod64;
	                const padding = new Uint8Array(padLength);
	                files[filename] = [
	                    file,
	                    {
	                        extra: {
	                            12345: padding
	                        }
	                    }
	                ];
	            }
	            offset = file.length;
	        }
	        return zipSync(files, {
	            level: 0
	        });
	    }
	    constructor(){
	        this.textureUtils = null;
	    }
	}
	function imageToCanvas(image, flipY, maxTextureSize) {
	    if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
	        const scale = maxTextureSize / Math.max(image.width, image.height);
	        const canvas = document.createElement('canvas');
	        canvas.width = image.width * Math.min(1, scale);
	        canvas.height = image.height * Math.min(1, scale);
	        const context = canvas.getContext('2d');
	        // TODO: We should be able to do this in the UsdTransform2d?
	        if (flipY === true) {
	            context.translate(0, canvas.height);
	            context.scale(1, -1);
	        }
	        context.drawImage(image, 0, 0, canvas.width, canvas.height);
	        return canvas;
	    } else {
	        throw new Error('THREE.USDZExporter: No valid image data found. Unable to process texture.');
	    }
	}
	//
	const PRECISION = 7;
	function buildHeader() {
	    return `#usda 1.0
(
	customLayerData = {
		string creator = "Three.js USDZExporter"
	}
	defaultPrim = "Root"
	metersPerUnit = 1
	upAxis = "Y"
)

`;
	}
	function buildSceneStart(options) {
	    const alignment = options.includeAnchoringProperties === true ? `
		token preliminary:anchoring:type = "${options.ar.anchoring.type}"
		token preliminary:planeAnchoring:alignment = "${options.ar.planeAnchoring.alignment}"
	` : '';
	    return `def Xform "Root"
{
	def Scope "Scenes" (
		kind = "sceneLibrary"
	)
	{
		def Xform "Scene" (
			customData = {
				bool preliminary_collidesWithEnvironment = 0
				string sceneName = "Scene"
			}
			sceneName = "Scene"
		)
		{${alignment}
`;
	}
	function buildSceneEnd() {
	    return `
		}
	}
}

`;
	}
	function buildUSDFileAsString(dataToInsert) {
	    let output = buildHeader();
	    output += dataToInsert;
	    return strToU8(output);
	}
	// Xform
	function buildXform(object, geometry, material) {
	    const name = 'Object_' + object.id;
	    const transform = buildMatrix(object.matrixWorld);
	    if (object.matrixWorld.determinant() < 0) {
	        console.warn('THREE.USDZExporter: USDZ does not support negative scales', object);
	    }
	    return `def Xform "${name}" (
	prepend references = @./geometries/Geometry_${geometry.id}.usda@</Geometry>
	prepend apiSchemas = ["MaterialBindingAPI"]
)
{
	matrix4d xformOp:transform = ${transform}
	uniform token[] xformOpOrder = ["xformOp:transform"]

	rel material:binding = </Materials/Material_${material.id}>
}

`;
	}
	function buildMatrix(matrix) {
	    const array = matrix.elements;
	    return `( ${buildMatrixRow(array, 0)}, ${buildMatrixRow(array, 4)}, ${buildMatrixRow(array, 8)}, ${buildMatrixRow(array, 12)} )`;
	}
	function buildMatrixRow(array, offset) {
	    return `(${array[offset + 0]}, ${array[offset + 1]}, ${array[offset + 2]}, ${array[offset + 3]})`;
	}
	// Mesh
	function buildMeshObject(geometry) {
	    const mesh = buildMesh(geometry);
	    return `
def "Geometry"
{
${mesh}
}
`;
	}
	function buildMesh(geometry) {
	    const name = 'Geometry';
	    const attributes = geometry.attributes;
	    const count = attributes.position.count;
	    return `
	def Mesh "${name}"
	{
		int[] faceVertexCounts = [${buildMeshVertexCount(geometry)}]
		int[] faceVertexIndices = [${buildMeshVertexIndices(geometry)}]
		normal3f[] normals = [${buildVector3Array(attributes.normal, count)}] (
			interpolation = "vertex"
		)
		point3f[] points = [${buildVector3Array(attributes.position, count)}]
${buildPrimvars(attributes)}
		uniform token subdivisionScheme = "none"
	}
`;
	}
	function buildMeshVertexCount(geometry) {
	    const count = geometry.index !== null ? geometry.index.count : geometry.attributes.position.count;
	    return Array(count / 3).fill(3).join(', ');
	}
	function buildMeshVertexIndices(geometry) {
	    const index = geometry.index;
	    const array = [];
	    if (index !== null) {
	        for(let i = 0; i < index.count; i++){
	            array.push(index.getX(i));
	        }
	    } else {
	        const length = geometry.attributes.position.count;
	        for(let i = 0; i < length; i++){
	            array.push(i);
	        }
	    }
	    return array.join(', ');
	}
	function buildVector3Array(attribute, count) {
	    if (attribute === undefined) {
	        console.warn('USDZExporter: Normals missing.');
	        return Array(count).fill('(0, 0, 0)').join(', ');
	    }
	    const array = [];
	    for(let i = 0; i < attribute.count; i++){
	        const x = attribute.getX(i);
	        const y = attribute.getY(i);
	        const z = attribute.getZ(i);
	        array.push(`(${x.toPrecision(PRECISION)}, ${y.toPrecision(PRECISION)}, ${z.toPrecision(PRECISION)})`);
	    }
	    return array.join(', ');
	}
	function buildVector2Array(attribute) {
	    const array = [];
	    for(let i = 0; i < attribute.count; i++){
	        const x = attribute.getX(i);
	        const y = attribute.getY(i);
	        array.push(`(${x.toPrecision(PRECISION)}, ${1 - y.toPrecision(PRECISION)})`);
	    }
	    return array.join(', ');
	}
	function buildPrimvars(attributes) {
	    let string = '';
	    for(let i = 0; i < 4; i++){
	        const id = i > 0 ? i : '';
	        const attribute = attributes['uv' + id];
	        if (attribute !== undefined) {
	            string += `
		texCoord2f[] primvars:st${id} = [${buildVector2Array(attribute)}] (
			interpolation = "vertex"
		)`;
	        }
	    }
	    // vertex colors
	    const colorAttribute = attributes.color;
	    if (colorAttribute !== undefined) {
	        const count = colorAttribute.count;
	        string += `
	color3f[] primvars:displayColor = [${buildVector3Array(colorAttribute, count)}] (
		interpolation = "vertex"
		)`;
	    }
	    return string;
	}
	// Materials
	function buildMaterials(materials, textures, quickLookCompatible = false) {
	    const array = [];
	    for(const uuid in materials){
	        const material = materials[uuid];
	        array.push(buildMaterial(material, textures, quickLookCompatible));
	    }
	    return `def "Materials"
{
${array.join('')}
}

`;
	}
	function buildMaterial(material, textures, quickLookCompatible = false) {
	    // https://graphics.pixar.com/usd/docs/UsdPreviewSurface-Proposal.html
	    const pad = '			';
	    const inputs = [];
	    const samplers = [];
	    function buildTexture(texture, mapType, color) {
	        const id = texture.source.id + '_' + texture.flipY;
	        textures[id] = texture;
	        const uv = texture.channel > 0 ? 'st' + texture.channel : 'st';
	        const WRAPPINGS = {
	            1000: 'repeat',
	            1001: 'clamp',
	            1002: 'mirror' // MirroredRepeatWrapping
	        };
	        const repeat = texture.repeat.clone();
	        const offset = texture.offset.clone();
	        const rotation = texture.rotation;
	        // rotation is around the wrong point. after rotation we need to shift offset again so that we're rotating around the right spot
	        const xRotationOffset = Math.sin(rotation);
	        const yRotationOffset = Math.cos(rotation);
	        // texture coordinates start in the opposite corner, need to correct
	        offset.y = 1 - offset.y - repeat.y;
	        // turns out QuickLook is buggy and interprets texture repeat inverted/applies operations in a different order.
	        // Apple Feedback: 	FB10036297 and FB11442287
	        if (quickLookCompatible) {
	            // This is NOT correct yet in QuickLook, but comes close for a range of models.
	            // It becomes more incorrect the bigger the offset is
	            offset.x = offset.x / repeat.x;
	            offset.y = offset.y / repeat.y;
	            offset.x += xRotationOffset / repeat.x;
	            offset.y += yRotationOffset - 1;
	        } else {
	            // results match glTF results exactly. verified correct in usdview.
	            offset.x += xRotationOffset * repeat.x;
	            offset.y += (1 - yRotationOffset) * repeat.y;
	        }
	        return `
		def Shader "PrimvarReader_${mapType}"
		{
			uniform token info:id = "UsdPrimvarReader_float2"
			float2 inputs:fallback = (0.0, 0.0)
			token inputs:varname = "${uv}"
			float2 outputs:result
		}

		def Shader "Transform2d_${mapType}"
		{
			uniform token info:id = "UsdTransform2d"
			token inputs:in.connect = </Materials/Material_${material.id}/PrimvarReader_${mapType}.outputs:result>
			float inputs:rotation = ${(rotation * (180 / Math.PI)).toFixed(PRECISION)}
			float2 inputs:scale = ${buildVector2(repeat)}
			float2 inputs:translation = ${buildVector2(offset)}
			float2 outputs:result
		}

		def Shader "Texture_${texture.id}_${mapType}"
		{
			uniform token info:id = "UsdUVTexture"
			asset inputs:file = @textures/Texture_${id}.png@
			float2 inputs:st.connect = </Materials/Material_${material.id}/Transform2d_${mapType}.outputs:result>
			${color !== undefined ? 'float4 inputs:scale = ' + buildColor4(color) : ''}
			token inputs:sourceColorSpace = "${texture.colorSpace === NoColorSpace ? 'raw' : 'sRGB'}"
			token inputs:wrapS = "${WRAPPINGS[texture.wrapS]}"
			token inputs:wrapT = "${WRAPPINGS[texture.wrapT]}"
			float outputs:r
			float outputs:g
			float outputs:b
			float3 outputs:rgb
			${material.transparent || material.alphaTest > 0.0 ? 'float outputs:a' : ''}
		}`;
	    }
	    if (material.side === DoubleSide) {
	        console.warn('THREE.USDZExporter: USDZ does not support double sided materials', material);
	    }
	    if (material.map !== null) {
	        inputs.push(`${pad}color3f inputs:diffuseColor.connect = </Materials/Material_${material.id}/Texture_${material.map.id}_diffuse.outputs:rgb>`);
	        if (material.transparent) {
	            inputs.push(`${pad}float inputs:opacity.connect = </Materials/Material_${material.id}/Texture_${material.map.id}_diffuse.outputs:a>`);
	        } else if (material.alphaTest > 0.0) {
	            inputs.push(`${pad}float inputs:opacity.connect = </Materials/Material_${material.id}/Texture_${material.map.id}_diffuse.outputs:a>`);
	            inputs.push(`${pad}float inputs:opacityThreshold = ${material.alphaTest}`);
	        }
	        samplers.push(buildTexture(material.map, 'diffuse', material.color));
	    } else {
	        inputs.push(`${pad}color3f inputs:diffuseColor = ${buildColor(material.color)}`);
	    }
	    if (material.emissiveMap !== null) {
	        inputs.push(`${pad}color3f inputs:emissiveColor.connect = </Materials/Material_${material.id}/Texture_${material.emissiveMap.id}_emissive.outputs:rgb>`);
	        samplers.push(buildTexture(material.emissiveMap, 'emissive', new Color(material.emissive.r * material.emissiveIntensity, material.emissive.g * material.emissiveIntensity, material.emissive.b * material.emissiveIntensity)));
	    } else if (material.emissive.getHex() > 0) {
	        inputs.push(`${pad}color3f inputs:emissiveColor = ${buildColor(material.emissive)}`);
	    }
	    if (material.normalMap !== null) {
	        inputs.push(`${pad}normal3f inputs:normal.connect = </Materials/Material_${material.id}/Texture_${material.normalMap.id}_normal.outputs:rgb>`);
	        samplers.push(buildTexture(material.normalMap, 'normal'));
	    }
	    if (material.aoMap !== null) {
	        inputs.push(`${pad}float inputs:occlusion.connect = </Materials/Material_${material.id}/Texture_${material.aoMap.id}_occlusion.outputs:r>`);
	        samplers.push(buildTexture(material.aoMap, 'occlusion', new Color(material.aoMapIntensity, material.aoMapIntensity, material.aoMapIntensity)));
	    }
	    if (material.roughnessMap !== null) {
	        inputs.push(`${pad}float inputs:roughness.connect = </Materials/Material_${material.id}/Texture_${material.roughnessMap.id}_roughness.outputs:g>`);
	        samplers.push(buildTexture(material.roughnessMap, 'roughness', new Color(material.roughness, material.roughness, material.roughness)));
	    } else {
	        inputs.push(`${pad}float inputs:roughness = ${material.roughness}`);
	    }
	    if (material.metalnessMap !== null) {
	        inputs.push(`${pad}float inputs:metallic.connect = </Materials/Material_${material.id}/Texture_${material.metalnessMap.id}_metallic.outputs:b>`);
	        samplers.push(buildTexture(material.metalnessMap, 'metallic', new Color(material.metalness, material.metalness, material.metalness)));
	    } else {
	        inputs.push(`${pad}float inputs:metallic = ${material.metalness}`);
	    }
	    if (material.alphaMap !== null) {
	        inputs.push(`${pad}float inputs:opacity.connect = </Materials/Material_${material.id}/Texture_${material.alphaMap.id}_opacity.outputs:r>`);
	        inputs.push(`${pad}float inputs:opacityThreshold = 0.0001`);
	        samplers.push(buildTexture(material.alphaMap, 'opacity'));
	    } else {
	        inputs.push(`${pad}float inputs:opacity = ${material.opacity}`);
	    }
	    if (material.isMeshPhysicalMaterial) {
	        if (material.clearcoatMap !== null) {
	            inputs.push(`${pad}float inputs:clearcoat.connect = </Materials/Material_${material.id}/Texture_${material.clearcoatMap.id}_clearcoat.outputs:r>`);
	            samplers.push(buildTexture(material.clearcoatMap, 'clearcoat', new Color(material.clearcoat, material.clearcoat, material.clearcoat)));
	        } else {
	            inputs.push(`${pad}float inputs:clearcoat = ${material.clearcoat}`);
	        }
	        if (material.clearcoatRoughnessMap !== null) {
	            inputs.push(`${pad}float inputs:clearcoatRoughness.connect = </Materials/Material_${material.id}/Texture_${material.clearcoatRoughnessMap.id}_clearcoatRoughness.outputs:g>`);
	            samplers.push(buildTexture(material.clearcoatRoughnessMap, 'clearcoatRoughness', new Color(material.clearcoatRoughness, material.clearcoatRoughness, material.clearcoatRoughness)));
	        } else {
	            inputs.push(`${pad}float inputs:clearcoatRoughness = ${material.clearcoatRoughness}`);
	        }
	        inputs.push(`${pad}float inputs:ior = ${material.ior}`);
	    }
	    return `
	def Material "Material_${material.id}"
	{
		def Shader "PreviewSurface"
		{
			uniform token info:id = "UsdPreviewSurface"
${inputs.join('\n')}
			int inputs:useSpecularWorkflow = 0
			token outputs:surface
		}

		token outputs:surface.connect = </Materials/Material_${material.id}/PreviewSurface.outputs:surface>

${samplers.join('\n')}

	}
`;
	}
	function buildColor(color) {
	    return `(${color.r}, ${color.g}, ${color.b})`;
	}
	function buildColor4(color) {
	    return `(${color.r}, ${color.g}, ${color.b}, 1.0)`;
	}
	function buildVector2(vector) {
	    return `(${vector.x}, ${vector.y})`;
	}
	function buildCamera(camera) {
	    const name = camera.name ? camera.name : 'Camera_' + camera.id;
	    const transform = buildMatrix(camera.matrixWorld);
	    if (camera.matrixWorld.determinant() < 0) {
	        console.warn('THREE.USDZExporter: USDZ does not support negative scales', camera);
	    }
	    if (camera.isOrthographicCamera) {
	        return `def Camera "${name}"
		{
			matrix4d xformOp:transform = ${transform}
			uniform token[] xformOpOrder = ["xformOp:transform"]

			float2 clippingRange = (${camera.near.toPrecision(PRECISION)}, ${camera.far.toPrecision(PRECISION)})
			float horizontalAperture = ${((Math.abs(camera.left) + Math.abs(camera.right)) * 10).toPrecision(PRECISION)}
			float verticalAperture = ${((Math.abs(camera.top) + Math.abs(camera.bottom)) * 10).toPrecision(PRECISION)}
			token projection = "orthographic"
		}
	
	`;
	    } else {
	        return `def Camera "${name}"
		{
			matrix4d xformOp:transform = ${transform}
			uniform token[] xformOpOrder = ["xformOp:transform"]

			float2 clippingRange = (${camera.near.toPrecision(PRECISION)}, ${camera.far.toPrecision(PRECISION)})
			float focalLength = ${camera.getFocalLength().toPrecision(PRECISION)}
			float focusDistance = ${camera.focus.toPrecision(PRECISION)}
			float horizontalAperture = ${camera.getFilmWidth().toPrecision(PRECISION)}
			token projection = "perspective"
			float verticalAperture = ${camera.getFilmHeight().toPrecision(PRECISION)}
		}
	
	`;
	    }
	}

	const enumerationDeserializer = (allowedNames)=>(valueString)=>{
	        try {
	            const expressions = parseExpressions(valueString);
	            const names = (expressions.length ? expressions[0].terms : []).filter((valueNode)=>valueNode && valueNode.type === 'ident').map((valueNode)=>valueNode.value).filter((name)=>allowedNames.indexOf(name) > -1);
	            return new Set(names);
	        } catch (_error) {}
	        return new Set();
	    };

	var __decorate$2 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	let isWebXRBlocked = false;
	let isSceneViewerBlocked = false;
	const noArViewerSigil = '#model-viewer-no-ar-fallback';
	const deserializeARModes = enumerationDeserializer([
	    'quick-look',
	    'scene-viewer',
	    'webxr',
	    'none'
	]);
	const DEFAULT_AR_MODES = 'webxr scene-viewer quick-look';
	const ARMode = {
	    QUICK_LOOK: 'quick-look',
	    SCENE_VIEWER: 'scene-viewer',
	    WEBXR: 'webxr',
	    NONE: 'none'
	};
	const $arButtonContainer = Symbol('arButtonContainer');
	const $enterARWithWebXR = Symbol('enterARWithWebXR');
	const $openSceneViewer = Symbol('openSceneViewer');
	const $openIOSARQuickLook = Symbol('openIOSARQuickLook');
	const $canActivateAR = Symbol('canActivateAR');
	const $arMode = Symbol('arMode');
	const $arModes = Symbol('arModes');
	const $arAnchor = Symbol('arAnchor');
	const $preload = Symbol('preload');
	const $onARButtonContainerClick = Symbol('onARButtonContainerClick');
	const $onARStatus = Symbol('onARStatus');
	const $onARTracking = Symbol('onARTracking');
	const $onARTap = Symbol('onARTap');
	const $selectARMode = Symbol('selectARMode');
	const $triggerLoad = Symbol('triggerLoad');
	const ARMixin = (ModelViewerElement)=>{
	    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
	    class ARModelViewerElement extends ModelViewerElement {
	        get canActivateAR() {
	            return this[$arMode] !== ARMode.NONE;
	        }
	        connectedCallback() {
	            super.connectedCallback();
	            this[$renderer].arRenderer.addEventListener('status', this[$onARStatus]);
	            this.setAttribute('ar-status', ARStatus.NOT_PRESENTING);
	            this[$renderer].arRenderer.addEventListener('tracking', this[$onARTracking]);
	            this[$arAnchor].addEventListener('message', this[$onARTap]);
	        }
	        disconnectedCallback() {
	            super.disconnectedCallback();
	            this[$renderer].arRenderer.removeEventListener('status', this[$onARStatus]);
	            this[$renderer].arRenderer.removeEventListener('tracking', this[$onARTracking]);
	            this[$arAnchor].removeEventListener('message', this[$onARTap]);
	        }
	        update(changedProperties) {
	            super.update(changedProperties);
	            if (changedProperties.has('arScale')) {
	                this[$scene].canScale = this.arScale !== 'fixed';
	            }
	            if (changedProperties.has('arPlacement')) {
	                this[$scene].updateShadow();
	                this[$needsRender]();
	            }
	            if (changedProperties.has('arModes')) {
	                this[$arModes] = deserializeARModes(this.arModes);
	            }
	            if (changedProperties.has('ar') || changedProperties.has('arModes') || changedProperties.has('src') || changedProperties.has('iosSrc') || changedProperties.has('arUsdzMaxTextureSize')) {
	                this[$selectARMode]();
	            }
	        }
	 async activateAR() {
	            switch(this[$arMode]){
	                case ARMode.QUICK_LOOK:
	                    await this[$openIOSARQuickLook]();
	                    break;
	                case ARMode.WEBXR:
	                    await this[$enterARWithWebXR]();
	                    break;
	                case ARMode.SCENE_VIEWER:
	                    this[$openSceneViewer]();
	                    break;
	                default:
	                    console.warn('No AR Mode can be activated. This is probably due to missing \
configuration or device capabilities');
	                    break;
	            }
	        }
	        async [(_a = $canActivateAR, _b = $arButtonContainer, _c = $arAnchor, _d = $arModes, _e = $arMode, _f = $preload, _g = $onARButtonContainerClick, _h = $onARStatus, _j = $onARTracking, _k = $onARTap, $selectARMode)]() {
	            var _l;
	            let arMode = ARMode.NONE;
	            if (this.ar) {
	                if (this.src != null) {
	                    for (const value of this[$arModes]){
	                        if (value === 'webxr' && IS_WEBXR_AR_CANDIDATE && !isWebXRBlocked && await this[$renderer].arRenderer.supportsPresentation()) {
	                            arMode = ARMode.WEBXR;
	                            break;
	                        }
	                        if (value === 'scene-viewer' && !isSceneViewerBlocked && (IS_SCENEVIEWER_CANDIDATE || navigator.userAgentData && navigator.userAgentData.getHighEntropyValues && ((_l = (await navigator.userAgentData.getHighEntropyValues([
	                            'formFactor'
	                        ])).formFactor) === null || _l === void 0 ? void 0 : _l.includes('XR')))) {
	                            arMode = ARMode.SCENE_VIEWER;
	                            break;
	                        }
	                        if (value === 'quick-look' && IS_AR_QUICKLOOK_CANDIDATE) {
	                            arMode = ARMode.QUICK_LOOK;
	                            break;
	                        }
	                    }
	                }
	                if (arMode === ARMode.NONE && this.iosSrc != null && IS_AR_QUICKLOOK_CANDIDATE) {
	                    arMode = ARMode.QUICK_LOOK;
	                }
	            }
	            if (arMode !== ARMode.NONE) {
	                this[$arButtonContainer].classList.add('enabled');
	                this[$arButtonContainer].addEventListener('click', this[$onARButtonContainerClick]);
	            } else if (this[$arButtonContainer].classList.contains('enabled')) {
	                this[$arButtonContainer].removeEventListener('click', this[$onARButtonContainerClick]);
	                this[$arButtonContainer].classList.remove('enabled');
	                const status = ARStatus.FAILED;
	                this.setAttribute('ar-status', status);
	                this.dispatchEvent(new CustomEvent('ar-status', {
	                    detail: {
	                        status
	                    }
	                }));
	            }
	            this[$arMode] = arMode;
	        }
	        async [$enterARWithWebXR]() {
	            console.log('Attempting to present in AR with WebXR...');
	            await this[$triggerLoad]();
	            try {
	                this[$arButtonContainer].removeEventListener('click', this[$onARButtonContainerClick]);
	                const { arRenderer } = this[$renderer];
	                arRenderer.placeOnWall = this.arPlacement === 'wall';
	                await arRenderer.present(this[$scene], this.xrEnvironment);
	            } catch (error) {
	                console.warn('Error while trying to present in AR with WebXR');
	                console.error(error);
	                await this[$renderer].arRenderer.stopPresenting();
	                isWebXRBlocked = true;
	                console.warn('Falling back to next ar-mode');
	                await this[$selectARMode]();
	                this.activateAR();
	            } finally{
	                this[$selectARMode]();
	            }
	        }
	        async [$triggerLoad]() {
	            if (!this.loaded) {
	                this[$preload] = true;
	                this[$updateSource]();
	                await waitForEvent(this, 'load');
	                this[$preload] = false;
	            }
	        }
	        [$shouldAttemptPreload]() {
	            return super[$shouldAttemptPreload]() || this[$preload];
	        }
	 [$openSceneViewer]() {
	            const location = self.location.toString();
	            const locationUrl = new URL(location);
	            const modelUrl = new URL(this.src, location);
	            if (modelUrl.hash) modelUrl.hash = '';
	            const params = new URLSearchParams(modelUrl.search);
	            locationUrl.hash = noArViewerSigil;
	            params.set('mode', 'ar_preferred');
	            if (!params.has('disable_occlusion')) {
	                params.set('disable_occlusion', 'true');
	            }
	            if (this.arScale === 'fixed') {
	                params.set('resizable', 'false');
	            }
	            if (this.arPlacement === 'wall') {
	                params.set('enable_vertical_placement', 'true');
	            }
	            if (params.has('sound')) {
	                const soundUrl = new URL(params.get('sound'), location);
	                params.set('sound', soundUrl.toString());
	            }
	            if (params.has('link')) {
	                const linkUrl = new URL(params.get('link'), location);
	                params.set('link', linkUrl.toString());
	            }
	            const intent = `intent://arvr.google.com/scene-viewer/1.2?${params.toString() + '&file=' + encodeURIComponent(modelUrl.toString())}#Intent;scheme=https;package=com.google.android.googlequicksearchbox;action=android.intent.action.VIEW;S.browser_fallback_url=${encodeURIComponent(locationUrl.toString())};end;`;
	            const undoHashChange = ()=>{
	                if (self.location.hash === noArViewerSigil) {
	                    isSceneViewerBlocked = true;
	                    self.history.back();
	                    console.warn('Error while trying to present in AR with Scene Viewer');
	                    console.warn('Falling back to next ar-mode');
	                    this[$selectARMode]();
	                }
	            };
	            self.addEventListener('hashchange', undoHashChange, {
	                once: true
	            });
	            this[$arAnchor].setAttribute('href', intent);
	            console.log('Attempting to present in AR with Scene Viewer...');
	            this[$arAnchor].click();
	        }
	 async [$openIOSARQuickLook]() {
	            const generateUsdz = !this.iosSrc;
	            this[$arButtonContainer].classList.remove('enabled');
	            const objectURL = generateUsdz ? await this.prepareUSDZ() : this.iosSrc;
	            const modelUrl = new URL(objectURL, self.location.toString());
	            if (generateUsdz) {
	                const location = self.location.toString();
	                const locationUrl = new URL(location);
	                const srcUrl = new URL(this.src, locationUrl);
	                if (srcUrl.hash) {
	                    modelUrl.hash = srcUrl.hash;
	                }
	            }
	            if (this.arScale === 'fixed') {
	                if (modelUrl.hash) {
	                    modelUrl.hash += '&';
	                }
	                modelUrl.hash += 'allowsContentScaling=0';
	            }
	            const anchor = this[$arAnchor];
	            anchor.setAttribute('rel', 'ar');
	            const img = document.createElement('img');
	            anchor.appendChild(img);
	            anchor.setAttribute('href', modelUrl.toString());
	            if (generateUsdz) {
	                anchor.setAttribute('download', 'model.usdz');
	            }
	            anchor.style.display = 'none';
	            if (!anchor.isConnected) this.shadowRoot.appendChild(anchor);
	            console.log('Attempting to present in AR with Quick Look...');
	            anchor.click();
	            anchor.removeChild(img);
	            if (generateUsdz) {
	                URL.revokeObjectURL(objectURL);
	            }
	            this[$arButtonContainer].classList.add('enabled');
	        }
	        async prepareUSDZ() {
	            const updateSourceProgress = this[$progressTracker].beginActivity('usdz-conversion');
	            await this[$triggerLoad]();
	            const { model, shadow, target } = this[$scene];
	            if (model == null) {
	                return '';
	            }
	            let visible = false;
	            if (shadow != null) {
	                visible = shadow.visible;
	                shadow.visible = false;
	            }
	            updateSourceProgress(0.2);
	            const exporter = new USDZExporter();
	            target.remove(model);
	            model.position.copy(target.position);
	            model.updateWorldMatrix(false, true);
	            const arraybuffer = await exporter.parseAsync(model, {
	                maxTextureSize: isNaN(this.arUsdzMaxTextureSize) ? Infinity : Math.max(parseInt(this.arUsdzMaxTextureSize), 16)
	            });
	            model.position.set(0, 0, 0);
	            target.add(model);
	            const blob = new Blob([
	                arraybuffer
	            ], {
	                type: 'model/vnd.usdz+zip'
	            });
	            const url = URL.createObjectURL(blob);
	            updateSourceProgress(1);
	            if (shadow != null) {
	                shadow.visible = visible;
	            }
	            return url;
	        }
	        constructor(){
	            super(...arguments);
	            this.ar = false;
	            this.arScale = 'auto';
	            this.arUsdzMaxTextureSize = 'auto';
	            this.arPlacement = 'floor';
	            this.arModes = DEFAULT_AR_MODES;
	            this.iosSrc = null;
	            this.xrEnvironment = false;
	            this[_a] = false;
	            this[_b] = this.shadowRoot.querySelector('.ar-button');
	            this[_c] = document.createElement('a');
	            this[_d] = new Set();
	            this[_e] = ARMode.NONE;
	            this[_f] = false;
	            this[_g] = (event)=>{
	                event.preventDefault();
	                this.activateAR();
	            };
	            this[_h] = ({ status })=>{
	                if (status === ARStatus.NOT_PRESENTING || this[$renderer].arRenderer.presentedScene === this[$scene]) {
	                    this.setAttribute('ar-status', status);
	                    this.dispatchEvent(new CustomEvent('ar-status', {
	                        detail: {
	                            status
	                        }
	                    }));
	                    if (status === ARStatus.NOT_PRESENTING) {
	                        this.removeAttribute('ar-tracking');
	                    } else if (status === ARStatus.SESSION_STARTED) {
	                        this.setAttribute('ar-tracking', ARTracking.TRACKING);
	                    }
	                }
	            };
	            this[_j] = ({ status })=>{
	                this.setAttribute('ar-tracking', status);
	                this.dispatchEvent(new CustomEvent('ar-tracking', {
	                    detail: {
	                        status
	                    }
	                }));
	            };
	            this[_k] = (event)=>{
	                if (event.data == '_apple_ar_quicklook_button_tapped') {
	                    this.dispatchEvent(new CustomEvent('quick-look-button-tapped'));
	                }
	            };
	        }
	    }
	    __decorate$2([
	        n$2({
	            type: Boolean,
	            attribute: 'ar'
	        })
	    ], ARModelViewerElement.prototype, "ar", void 0);
	    __decorate$2([
	        n$2({
	            type: String,
	            attribute: 'ar-scale'
	        })
	    ], ARModelViewerElement.prototype, "arScale", void 0);
	    __decorate$2([
	        n$2({
	            type: String,
	            attribute: 'ar-usdz-max-texture-size'
	        })
	    ], ARModelViewerElement.prototype, "arUsdzMaxTextureSize", void 0);
	    __decorate$2([
	        n$2({
	            type: String,
	            attribute: 'ar-placement'
	        })
	    ], ARModelViewerElement.prototype, "arPlacement", void 0);
	    __decorate$2([
	        n$2({
	            type: String,
	            attribute: 'ar-modes'
	        })
	    ], ARModelViewerElement.prototype, "arModes", void 0);
	    __decorate$2([
	        n$2({
	            type: String,
	            attribute: 'ios-src'
	        })
	    ], ARModelViewerElement.prototype, "iosSrc", void 0);
	    __decorate$2([
	        n$2({
	            type: Boolean,
	            attribute: 'xr-environment'
	        })
	    ], ARModelViewerElement.prototype, "xrEnvironment", void 0);
	    return ARModelViewerElement;
	};

	var __decorate$1 = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	const PROGRESS_BAR_UPDATE_THRESHOLD = 100;
	const DEFAULT_DRACO_DECODER_LOCATION = (window.explorexrPluginUrl || '/wp-content/plugins/explorexr/') + 'assets/vendor/draco/';
	const DEFAULT_KTX2_TRANSCODER_LOCATION = (window.explorexrPluginUrl || '/wp-content/plugins/explorexr/') + 'assets/vendor/basis-universal/';
	const DEFAULT_LOTTIE_LOADER_LOCATION = (window.explorexrPluginUrl || '/wp-content/plugins/explorexr/') + 'assets/vendor/three/LottieLoader.js';
	const RevealStrategy = {
	    AUTO: 'auto'};
	const LoadingStrategy = {
	    AUTO: 'auto',
	    EAGER: 'eager'
	};
	const $defaultProgressBarElement = Symbol('defaultProgressBarElement');
	const $posterContainerElement = Symbol('posterContainerElement');
	const $defaultPosterElement = Symbol('defaultPosterElement');
	const $shouldDismissPoster = Symbol('shouldDismissPoster');
	const $hidePoster = Symbol('hidePoster');
	const $modelIsRevealed = Symbol('modelIsRevealed');
	const $updateProgressBar = Symbol('updateProgressBar');
	const $ariaLabelCallToAction = Symbol('ariaLabelCallToAction');
	const $onProgress = Symbol('onProgress');
	 const LoadingMixin = (ModelViewerElement)=>{
	    var _a, _b, _c, _d, _e, _f, _g, _h;
	    class LoadingModelViewerElement extends ModelViewerElement {
	        static set dracoDecoderLocation(value) {
	            CachingGLTFLoader.setDRACODecoderLocation(value);
	        }
	        static get dracoDecoderLocation() {
	            return CachingGLTFLoader.getDRACODecoderLocation();
	        }
	        static set ktx2TranscoderLocation(value) {
	            CachingGLTFLoader.setKTX2TranscoderLocation(value);
	        }
	        static get ktx2TranscoderLocation() {
	            return CachingGLTFLoader.getKTX2TranscoderLocation();
	        }
	        static set meshoptDecoderLocation(value) {
	            CachingGLTFLoader.setMeshoptDecoderLocation(value);
	        }
	        static get meshoptDecoderLocation() {
	            return CachingGLTFLoader.getMeshoptDecoderLocation();
	        }
	        static set lottieLoaderLocation(value) {
	            Renderer.singleton.textureUtils.lottieLoaderUrl = value;
	        }
	        static get lottieLoaderLocation() {
	            return Renderer.singleton.textureUtils.lottieLoaderUrl;
	        }
	 static mapURLs(callback) {
	            Renderer.singleton.loader[$loader].manager.setURLModifier(callback);
	        }
	 dismissPoster() {
	            if (this.loaded) {
	                this[$hidePoster]();
	            } else {
	                this[$shouldDismissPoster] = true;
	                this[$updateSource]();
	            }
	        }
	 showPoster() {
	            const posterContainerElement = this[$posterContainerElement];
	            if (posterContainerElement.classList.contains('show')) {
	                return;
	            }
	            posterContainerElement.classList.add('show');
	            this[$userInputElement].classList.remove('show');
	            const defaultPosterElement = this[$defaultPosterElement];
	            defaultPosterElement.removeAttribute('tabindex');
	            defaultPosterElement.removeAttribute('aria-hidden');
	            const oldVisibility = this.modelIsVisible;
	            this[$modelIsRevealed] = false;
	            this[$announceModelVisibility](oldVisibility);
	        }
	 getDimensions() {
	            return toVector3D(this[$scene].size);
	        }
	        getBoundingBoxCenter() {
	            return toVector3D(this[$scene].boundingBox.getCenter(new Vector3()));
	        }
	        connectedCallback() {
	            super.connectedCallback();
	            if (!this.loaded) {
	                this.showPoster();
	            }
	            this[$progressTracker].addEventListener('progress', this[$onProgress]);
	        }
	        disconnectedCallback() {
	            super.disconnectedCallback();
	            this[$progressTracker].removeEventListener('progress', this[$onProgress]);
	        }
	        async updated(changedProperties) {
	            super.updated(changedProperties);
	            if (changedProperties.has('poster') && this.poster != null) {
	                this[$defaultPosterElement].style.backgroundImage = `url(${this.poster})`;
	            }
	            if (changedProperties.has('alt')) {
	                this[$defaultPosterElement].setAttribute('aria-label', this[$altDefaulted]);
	            }
	            if (changedProperties.has('reveal') || changedProperties.has('loading')) {
	                this[$updateSource]();
	            }
	        }
	        [(_a = $modelIsRevealed, _b = $shouldDismissPoster, _c = $posterContainerElement, _d = $defaultPosterElement, _e = $defaultProgressBarElement, _f = $ariaLabelCallToAction, _g = $updateProgressBar, _h = $onProgress, $shouldAttemptPreload)]() {
	            return !!this.src && (this[$shouldDismissPoster] || this.loading === LoadingStrategy.EAGER || this.reveal === RevealStrategy.AUTO && this[$isElementInViewport]);
	        }
	        [$hidePoster]() {
	            this[$shouldDismissPoster] = false;
	            const posterContainerElement = this[$posterContainerElement];
	            if (!posterContainerElement.classList.contains('show')) {
	                return;
	            }
	            posterContainerElement.classList.remove('show');
	            this[$userInputElement].classList.add('show');
	            const oldVisibility = this.modelIsVisible;
	            this[$modelIsRevealed] = true;
	            this[$announceModelVisibility](oldVisibility);
	            const root = this.getRootNode();
	            if (root && root.activeElement === this) {
	                this[$userInputElement].focus();
	            }
	            const defaultPosterElement = this[$defaultPosterElement];
	            defaultPosterElement.setAttribute('aria-hidden', 'true');
	            defaultPosterElement.tabIndex = -1;
	            this.dispatchEvent(new CustomEvent('poster-dismissed'));
	        }
	        [$getModelIsVisible]() {
	            return super[$getModelIsVisible]() && this[$modelIsRevealed];
	        }
	        constructor(...args){
	            super(...args);
	 this.poster = null;
	 this.reveal = RevealStrategy.AUTO;
	 this.loading = LoadingStrategy.AUTO;
	            this[_a] = false;
	            this[_b] = false;
	            this[_c] = this.shadowRoot.querySelector('.slot.poster');
	            this[_d] = this.shadowRoot.querySelector('#default-poster');
	            this[_e] = this.shadowRoot.querySelector('#default-progress-bar > .bar');
	            this[_f] = this[$defaultPosterElement].getAttribute('aria-label');
	            this[_g] = throttle((progress)=>{
	                const parentNode = this[$defaultProgressBarElement].parentNode;
	                requestAnimationFrame(()=>{
	                    this[$defaultProgressBarElement].style.transform = `scaleX(${progress})`;
	                    if (progress === 0) {
	                        parentNode.removeChild(this[$defaultProgressBarElement]);
	                        parentNode.appendChild(this[$defaultProgressBarElement]);
	                    }
	                    this[$defaultProgressBarElement].classList.toggle('hide', progress === 1.0);
	                });
	            }, PROGRESS_BAR_UPDATE_THRESHOLD);
	            this[_h] = (event)=>{
	                const progress = event.detail.totalProgress;
	                const reason = event.detail.reason;
	                if (progress === 1.0) {
	                    this[$updateProgressBar].flush();
	                    if (this.loaded && (this[$shouldDismissPoster] || this.reveal === RevealStrategy.AUTO)) {
	                        this[$hidePoster]();
	                    }
	                }
	                this[$updateProgressBar](progress);
	                this.dispatchEvent(new CustomEvent('progress', {
	                    detail: {
	                        totalProgress: progress,
	                        reason
	                    }
	                }));
	            };
	            const ModelViewerElement = self.ModelViewerElement || {};
	            const dracoDecoderLocation = ModelViewerElement.dracoDecoderLocation || DEFAULT_DRACO_DECODER_LOCATION;
	            CachingGLTFLoader.setDRACODecoderLocation(dracoDecoderLocation);
	            const ktx2TranscoderLocation = ModelViewerElement.ktx2TranscoderLocation || DEFAULT_KTX2_TRANSCODER_LOCATION;
	            CachingGLTFLoader.setKTX2TranscoderLocation(ktx2TranscoderLocation);
	            if (ModelViewerElement.meshoptDecoderLocation) {
	                CachingGLTFLoader.setMeshoptDecoderLocation(ModelViewerElement.meshoptDecoderLocation);
	            }
	            const lottieLoaderLocation = ModelViewerElement.lottieLoaderLocation || DEFAULT_LOTTIE_LOADER_LOCATION;
	            Renderer.singleton.textureUtils.lottieLoaderUrl = lottieLoaderLocation;
	        }
	    }
	    __decorate$1([
	        n$2({
	            type: String
	        })
	    ], LoadingModelViewerElement.prototype, "poster", void 0);
	    __decorate$1([
	        n$2({
	            type: String
	        })
	    ], LoadingModelViewerElement.prototype, "reveal", void 0);
	    __decorate$1([
	        n$2({
	            type: String
	        })
	    ], LoadingModelViewerElement.prototype, "loading", void 0);
	    return LoadingModelViewerElement;
	};

	var __decorate = undefined && undefined.__decorate || function(decorators, target, key, desc) {
	    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	    for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	const DEFAULT_ROTATION_SPEED = Math.PI / 32;
	const AUTO_ROTATE_DELAY_DEFAULT = 3000;
	const rotationRateIntrinsics = {
	    basis: [
	        degreesToRadians(numberNode(DEFAULT_ROTATION_SPEED, 'rad'))
	    ],
	    keywords: {
	        auto: [
	            null
	        ]
	    }
	};
	const $autoRotateStartTime = Symbol('autoRotateStartTime');
	const $radiansPerSecond = Symbol('radiansPerSecond');
	const $syncRotationRate = Symbol('syncRotationRate');
	const $onCameraChange = Symbol('onCameraChange');
	const StagingMixin = (ModelViewerElement)=>{
	    var _a, _b, _c;
	    class StagingModelViewerElement extends ModelViewerElement {
	        connectedCallback() {
	            super.connectedCallback();
	            this.addEventListener('camera-change', this[$onCameraChange]);
	            this[$autoRotateStartTime] = performance.now();
	        }
	        disconnectedCallback() {
	            super.disconnectedCallback();
	            this.removeEventListener('camera-change', this[$onCameraChange]);
	            this[$autoRotateStartTime] = performance.now();
	        }
	        updated(changedProperties) {
	            super.updated(changedProperties);
	            if (changedProperties.has('autoRotate')) {
	                this[$autoRotateStartTime] = performance.now();
	            }
	        }
	        [(_a = $autoRotateStartTime, _b = $radiansPerSecond, $syncRotationRate)](style) {
	            this[$radiansPerSecond] = style[0];
	        }
	        [$tick](time, delta) {
	            super[$tick](time, delta);
	            if (!this.autoRotate || !this[$getModelIsVisible]() || this[$renderer].isPresenting) {
	                return;
	            }
	            const rotationDelta = Math.min(delta, time - this[$autoRotateStartTime] - this.autoRotateDelay);
	            if (rotationDelta > 0) {
	                this[$scene].yaw = this.turntableRotation + this[$radiansPerSecond] * rotationDelta * 0.001;
	            }
	        }
	        get turntableRotation() {
	            return this[$scene].yaw;
	        }
	        resetTurntableRotation(theta = 0) {
	            this[$scene].yaw = theta;
	        }
	        constructor(){
	            super(...arguments);
	            this.autoRotate = false;
	            this.autoRotateDelay = AUTO_ROTATE_DELAY_DEFAULT;
	            this.rotationPerSecond = 'auto';
	            this[_a] = performance.now();
	            this[_b] = 0;
	            this[_c] = (event)=>{
	                if (!this.autoRotate) {
	                    return;
	                }
	                if (event.detail.source === 'user-interaction') {
	                    this[$autoRotateStartTime] = performance.now();
	                }
	            };
	        }
	    }
	    _c = $onCameraChange;
	    __decorate([
	        n$2({
	            type: Boolean,
	            attribute: 'auto-rotate'
	        })
	    ], StagingModelViewerElement.prototype, "autoRotate", void 0);
	    __decorate([
	        n$2({
	            type: Number,
	            attribute: 'auto-rotate-delay'
	        })
	    ], StagingModelViewerElement.prototype, "autoRotateDelay", void 0);
	    __decorate([
	        style({
	            intrinsics: rotationRateIntrinsics,
	            updateHandler: $syncRotationRate
	        }),
	        n$2({
	            type: String,
	            attribute: 'rotation-per-second'
	        })
	    ], StagingModelViewerElement.prototype, "rotationPerSecond", void 0);
	    return StagingModelViewerElement;
	};

	const ModelViewerElement = AnnotationMixin(SceneGraphMixin(StagingMixin(EnvironmentMixin(ControlsMixin(ARMixin(LoadingMixin(AnimationMixin(ModelViewerElementBase))))))));
	customElements.define('model-viewer', ModelViewerElement);

	exports.CanvasTexture = CanvasTexture;
	exports.FileLoader = FileLoader;
	exports.Loader = Loader;
	exports.ModelViewerElement = ModelViewerElement;
	exports.NearestFilter = NearestFilter;

}));
//# sourceMappingURL=model-viewer-umd.js.map
