angular-three-soba 2.0.0-beta.21 → 2.0.0-beta.224

package/fesm2022/angular-three-soba-staging.mjs

@@ -1,4162 +0,0 @@
-import * as i0 from '@angular/core';
-import { forwardRef, computed, untracked, effect, Component, CUSTOM_ELEMENTS_SCHEMA, Input, EventEmitter, Output, Directive, runInInjectionContext, inject, ChangeDetectorRef, DestroyRef, TemplateRef, ContentChild, signal, isSignal } from '@angular/core';
-import { extend, createInjectionToken, signalStore, injectNgtRef, injectNgtStore, getLocalState, injectBeforeRender, NgtRepeat, NgtArgs, checkUpdate, is, assertInjectionContext, injectNgtLoader, safeDetectChanges, prepare, NgtPortal, NgtPortalContent, NgtKey } from 'angular-three';
-import { DiscardMaterial, SoftShadowMaterial, SparklesMaterial, SpotLightMaterial, StarFieldMaterial, WireframeMaterial, WireframeMaterialShaders, injectNgtsWireframeUniforms, setWireframeOverride } from 'angular-three-soba/shaders';
-import * as THREE from 'three';
-import { Group, Mesh, PlaneGeometry, DirectionalLight, OrthographicCamera, Vector2, MeshStandardMaterial, MeshBasicMaterial, CubeTextureLoader, CubeReflectionMapping, EquirectangularReflectionMapping, CubeCamera, Points, BufferGeometry, BufferAttribute, SpotLight, SpotLightHelper, AmbientLight, PointLight, Object3D } from 'three';
-import { SimplexNoise, HorizontalBlurShader, VerticalBlurShader, RGBELoader, EXRLoader, GroundProjectedEnv, Sky, FullScreenQuad } from 'three-stdlib';
-import { NgFor, NgIf, NgTemplateOutlet } from '@angular/common';
-import { NgtsBillboard } from 'angular-three-soba/abstractions';
-import { injectNgtsTextureLoader } from 'angular-three-soba/loaders';
-import { NgtsSobaContent } from 'angular-three-soba/utils';
-
-function isLight(object) {
-    return object.isLight;
-}
-function isGeometry(object) {
-    return !!object.geometry;
-}
-// Based on "Progressive Light Map Accumulator", by [zalo](https://github.com/zalo/)
-class ProgressiveLightMap {
-    constructor(renderer, scene, res = 1024) {
-        this.renderer = renderer;
-        this.res = res;
-        this.scene = scene;
-        this.buffer1Active = false;
-        this.lights = [];
-        this.meshes = [];
-        this.object = null;
-        this.clearColor = new THREE.Color();
-        this.clearAlpha = 0;
-        // Create the Progressive LightMap Texture
-        const format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? THREE.HalfFloatType : THREE.FloatType;
-        this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, {
-            type: format,
-        });
-        this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {
-            type: format,
-        });
-        // Inject some spicy new logic into a standard phong material
-        this.discardMat = new DiscardMaterial();
-        this.targetMat = new THREE.MeshLambertMaterial({ fog: false });
-        this.previousShadowMap = { value: this.progressiveLightMap1.texture };
-        this.averagingWindow = { value: 100 };
-        this.targetMat.onBeforeCompile = (shader) => {
-            // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
-            shader.vertexShader =
-                'varying vec2 vUv;\n' +
-                    shader.vertexShader.slice(0, -1) +
-                    'vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }';
-            // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
-            const bodyStart = shader.fragmentShader.indexOf('void main() {');
-            shader.fragmentShader =
-                'varying vec2 vUv;\n' +
-                    shader.fragmentShader.slice(0, bodyStart) +
-                    'uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' +
-                    shader.fragmentShader.slice(bodyStart - 1, -1) +
-                    `\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;
-        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);
-      }`;
-            // Set the Previous Frame's Texture Buffer and Averaging Window
-            // Set the Previous Frame's Texture Buffer and Averaging Window
-            shader.uniforms['previousShadowMap'] = this.previousShadowMap;
-            shader.uniforms['averagingWindow'] = this.averagingWindow;
-        };
-    }
-    clear() {
-        this.renderer.getClearColor(this.clearColor);
-        this.clearAlpha = this.renderer.getClearAlpha();
-        this.renderer.setClearColor('black', 1);
-        this.renderer.setRenderTarget(this.progressiveLightMap1);
-        this.renderer.clear();
-        this.renderer.setRenderTarget(this.progressiveLightMap2);
-        this.renderer.clear();
-        this.renderer.setRenderTarget(null);
-        this.renderer.setClearColor(this.clearColor, this.clearAlpha);
-        this.lights = [];
-        this.meshes = [];
-        this.scene.traverse((object) => {
-            if (isGeometry(object)) {
-                this.meshes.push({ object, material: object.material });
-            }
-            else if (isLight(object)) {
-                this.lights.push({ object, intensity: object.intensity });
-            }
-        });
-    }
-    prepare() {
-        this.lights.forEach((light) => (light.object.intensity = 0));
-        this.meshes.forEach((mesh) => (mesh.object.material = this.discardMat));
-    }
-    finish() {
-        this.lights.forEach((light) => (light.object.intensity = light.intensity));
-        this.meshes.forEach((mesh) => (mesh.object.material = mesh.material));
-    }
-    configure(object) {
-        this.object = object;
-    }
-    update(camera, blendWindow = 100) {
-        if (!this.object)
-            return;
-        // Set each object's material to the UV Unwrapped Surface Mapping Version
-        this.averagingWindow.value = blendWindow;
-        this.object.material = this.targetMat;
-        // Ping-pong two surface buffers for reading/writing
-        const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
-        const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;
-        // Render the object's surface maps
-        const oldBg = this.scene.background;
-        this.scene.background = null;
-        this.renderer.setRenderTarget(activeMap);
-        this.previousShadowMap.value = inactiveMap.texture;
-        this.buffer1Active = !this.buffer1Active;
-        this.renderer.render(this.scene, camera);
-        this.renderer.setRenderTarget(null);
-        this.scene.background = oldBg;
-    }
-}
-
-extend({ Group, SoftShadowMaterial, Mesh, PlaneGeometry });
-const [injectNgtsAccumulativeShadowsApi, provideNgtsAccumulativeShadowsApi] = createInjectionToken((shadows) => shadows.api, { isRoot: false, deps: [forwardRef(() => NgtsAccumulativeShadows)] });
-class NgtsAccumulativeShadows {
-    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
-    set _frames(frames) {
-        this.inputs.set({ frames });
-    }
-    /** If frames === Infinity blend controls the refresh ratio, 100 */
-    set _blend(blend) {
-        this.inputs.set({ blend });
-    }
-    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
-    set _limit(limit) {
-        this.inputs.set({ limit });
-    }
-    /** Scale of the plane,  */
-    set _scale(scale) {
-        this.inputs.set({ scale });
-    }
-    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
-    set _temporal(temporal) {
-        this.inputs.set({ temporal });
-    }
-    /** Opacity of the plane, 1 */
-    set _opacity(opacity) {
-        this.inputs.set({ opacity });
-    }
-    /** Discards alpha pixels, 0.65 */
-    set _alphaTest(alphaTest) {
-        this.inputs.set({ alphaTest });
-    }
-    /** Shadow color, black */
-    set _color(color) {
-        this.inputs.set({ color });
-    }
-    /** Colorblend, how much colors turn to black, 0 is black, 2 */
-    set _colorBlend(colorBlend) {
-        this.inputs.set({ colorBlend });
-    }
-    /** Buffer resolution, 1024 */
-    set _resolution(resolution) {
-        this.inputs.set({ resolution });
-    }
-    /** Texture tonemapping */
-    set _toneMapped(toneMapped) {
-        this.inputs.set({ toneMapped });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            frames: 40,
-            limit: Infinity,
-            blend: 20,
-            scale: 10,
-            opacity: 1,
-            alphaTest: 0.75,
-            color: 'black',
-            colorBlend: 2,
-            resolution: 1024,
-            toneMapped: true,
-            temporal: false,
-        });
-        this.nullTraverse = () => null;
-        this.Math = Math;
-        this.accumulativeShadowsRef = injectNgtRef();
-        this.meshRef = injectNgtRef();
-        this.store = injectNgtStore();
-        this.gl = this.store.select('gl');
-        this.scene = this.store.select('scene');
-        this.camera = this.store.select('camera');
-        this.invalidate = this.store.select('invalidate');
-        this.resolution = this.inputs.select('resolution');
-        this.alphaTest = this.inputs.select('alphaTest');
-        this.opacity = this.inputs.select('opacity');
-        this.temporal = this.inputs.select('temporal');
-        this.blend = this.inputs.select('blend');
-        this.frames = this.inputs.select('frames');
-        this.pLM = computed(() => new ProgressiveLightMap(untracked(this.gl), untracked(this.scene), this.resolution()));
-        this.scale = this.inputs.select('scale');
-        this.toneMapped = this.inputs.select('toneMapped');
-        this.color = this.inputs.select('color');
-        this.colorBlend = this.inputs.select('colorBlend');
-        this.map = computed(() => this.pLM().progressiveLightMap2.texture);
-        this.api = computed(() => {
-            const [pLM, alphaTest, opacity, camera, temporal, blend, frames] = [
-                this.pLM(),
-                this.alphaTest(),
-                this.opacity(),
-                this.camera(),
-                this.temporal(),
-                this.blend(),
-                this.frames(),
-            ];
-            const api = {
-                lights: new Map(),
-                temporal,
-                frames: Math.max(2, frames),
-                blend: Math.max(2, frames === Infinity ? blend : frames),
-                count: 0,
-                getMesh: () => this.meshRef.nativeElement,
-                reset: () => {
-                    if (!this.meshRef.nativeElement)
-                        return;
-                    // Clear buffers, reset opacities, set frame count to 0
-                    pLM.clear();
-                    const material = this.meshRef.nativeElement.material;
-                    material.opacity = 0;
-                    material.alphaTest = 0;
-                    api.count = 0;
-                },
-                update: (frames = 1) => {
-                    if (!this.meshRef.nativeElement)
-                        return;
-                    // Adapt the opacity-blend ratio to the number of frames
-                    const material = this.meshRef.nativeElement.material;
-                    if (!api.temporal) {
-                        material.opacity = opacity;
-                        material.alphaTest = alphaTest;
-                    }
-                    else {
-                        material.opacity = Math.min(opacity, material.opacity + opacity / api.blend);
-                        material.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / api.blend);
-                    }
-                    // Switch accumulative lights on
-                    this.accumulativeShadowsRef.nativeElement.visible = true;
-                    // Collect scene lights and meshes
-                    pLM.prepare();
-                    // Update the lightmap and the accumulative lights
-                    for (let i = 0; i < frames; i++) {
-                        api.lights.forEach((light) => light().update());
-                        pLM.update(camera, api.blend);
-                    }
-                    // Switch lights off
-                    this.accumulativeShadowsRef.nativeElement.visible = false;
-                    // Restore lights and meshes
-                    pLM.finish();
-                },
-            };
-            return api;
-        });
-        this.configure();
-        this.resetAndUpdate();
-        this.beforeRender();
-    }
-    configure() {
-        effect(() => {
-            const [pLM, mesh] = [this.pLM(), this.meshRef.nativeElement];
-            if (!mesh)
-                return;
-            pLM.configure(mesh);
-        });
-    }
-    resetAndUpdate() {
-        effect(() => {
-            const [, , mesh] = [
-                this.inputs.state(),
-                getLocalState(untracked(this.scene)).objects(),
-                this.meshRef.nativeElement,
-            ];
-            if (!mesh)
-                return;
-            const api = untracked(this.api);
-            // Reset internals, buffers, ...
-            api.reset();
-            // Update lightmap
-            if (!api.temporal && api.frames !== Infinity)
-                api.update(api.blend);
-        });
-    }
-    beforeRender() {
-        injectBeforeRender(() => {
-            const [api, limit] = [this.api(), this.inputs.get('limit')];
-            if ((api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {
-                this.invalidate();
-                api.update();
-                api.count++;
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsAccumulativeShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsAccumulativeShadows, isStandalone: true, selector: "ngts-accumulative-shadows", inputs: { accumulativeShadowsRef: "accumulativeShadowsRef", _frames: ["frames", "_frames"], _blend: ["blend", "_blend"], _limit: ["limit", "_limit"], _scale: ["scale", "_scale"], _temporal: ["temporal", "_temporal"], _opacity: ["opacity", "_opacity"], _alphaTest: ["alphaTest", "_alphaTest"], _color: ["color", "_color"], _colorBlend: ["colorBlend", "_colorBlend"], _resolution: ["resolution", "_resolution"], _toneMapped: ["toneMapped", "_toneMapped"] }, providers: [provideNgtsAccumulativeShadowsApi()], ngImport: i0, template: `
-		<ngt-group ngtCompound>
-			<ngt-group [traverse]="nullTraverse" [ref]="accumulativeShadowsRef">
-				<ng-content />
-			</ngt-group>
-			<ngt-mesh [receiveShadow]="true" [ref]="meshRef" [scale]="scale()" [rotation]="[-Math.PI / 2, 0, 0]">
-				<ngt-plane-geometry />
-				<ngt-soft-shadow-material
-					[transparent]="true"
-					[depthWrite]="false"
-					[toneMapped]="toneMapped()"
-					[color]="color()"
-					[blend]="colorBlend()"
-					[map]="map()"
-				/>
-			</ngt-mesh>
-		</ngt-group>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsAccumulativeShadows, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-accumulative-shadows',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound>
-			<ngt-group [traverse]="nullTraverse" [ref]="accumulativeShadowsRef">
-				<ng-content />
-			</ngt-group>
-			<ngt-mesh [receiveShadow]="true" [ref]="meshRef" [scale]="scale()" [rotation]="[-Math.PI / 2, 0, 0]">
-				<ngt-plane-geometry />
-				<ngt-soft-shadow-material
-					[transparent]="true"
-					[depthWrite]="false"
-					[toneMapped]="toneMapped()"
-					[color]="color()"
-					[blend]="colorBlend()"
-					[map]="map()"
-				/>
-			</ngt-mesh>
-		</ngt-group>
-	`,
-                    providers: [provideNgtsAccumulativeShadowsApi()],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { accumulativeShadowsRef: [{
-                type: Input
-            }], _frames: [{
-                type: Input,
-                args: [{ alias: 'frames' }]
-            }], _blend: [{
-                type: Input,
-                args: [{ alias: 'blend' }]
-            }], _limit: [{
-                type: Input,
-                args: [{ alias: 'limit' }]
-            }], _scale: [{
-                type: Input,
-                args: [{ alias: 'scale' }]
-            }], _temporal: [{
-                type: Input,
-                args: [{ alias: 'temporal' }]
-            }], _opacity: [{
-                type: Input,
-                args: [{ alias: 'opacity' }]
-            }], _alphaTest: [{
-                type: Input,
-                args: [{ alias: 'alphaTest' }]
-            }], _color: [{
-                type: Input,
-                args: [{ alias: 'color' }]
-            }], _colorBlend: [{
-                type: Input,
-                args: [{ alias: 'colorBlend' }]
-            }], _resolution: [{
-                type: Input,
-                args: [{ alias: 'resolution' }]
-            }], _toneMapped: [{
-                type: Input,
-                args: [{ alias: 'toneMapped' }]
-            }] } });
-
-extend({ Group, DirectionalLight, OrthographicCamera, Vector2 });
-class NgtsRandomizedLights {
-    /** How many frames it will jiggle the lights, 1.
-     *  Frames is context aware, if a provider like AccumulativeShadows exists, frames will be taken from there!  */
-    set _frames(frames) {
-        this.inputs.set({ frames });
-    }
-    /** Light position, [0, 0, 0] */
-    set _position(position) {
-        this.inputs.set({ position });
-    }
-    /** Radius of the jiggle, higher values make softer light, 5 */
-    set _radius(radius) {
-        this.inputs.set({ radius });
-    }
-    /** Amount of lights, 8 */
-    set _amount(amount) {
-        this.inputs.set({ amount });
-    }
-    /** Light intensity, 1 */
-    set _intensity(intensity) {
-        this.inputs.set({ intensity });
-    }
-    /** Ambient occlusion, lower values mean less AO, hight more, you can mix AO and directional light, 0.5 */
-    set _ambient(ambient) {
-        this.inputs.set({ ambient });
-    }
-    /** If the lights cast shadows, this is true by default */
-    set _castShadow(castShadow) {
-        this.inputs.set({ castShadow });
-    }
-    /** Default shadow bias, 0 */
-    set _bias(bias) {
-        this.inputs.set({ bias });
-    }
-    /** Default map size, 512 */
-    set _mapSize(mapSize) {
-        this.inputs.set({ mapSize });
-    }
-    /** Default size of the shadow camera, 10 */
-    set _size(size) {
-        this.inputs.set({ size });
-    }
-    /** Default shadow camera near, 0.5 */
-    set _near(near) {
-        this.inputs.set({ near });
-    }
-    /** Default shadow camera far, 500 */
-    set _far(far) {
-        this.inputs.set({ far });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            castShadow: true,
-            bias: 0.001,
-            mapSize: 512,
-            size: 5,
-            near: 0.5,
-            far: 500,
-            frames: 1,
-            position: [0, 0, 0],
-            radius: 1,
-            amount: 8,
-            intensity: 1,
-            ambient: 0.5,
-        });
-        this.Math = Math;
-        this.lightsRef = injectNgtRef();
-        this.position = this.inputs.select('position');
-        this.ambient = this.inputs.select('ambient');
-        this.radius = this.inputs.select('radius');
-        this.mapSize = this.inputs.select('mapSize');
-        this.size = this.inputs.select('size');
-        this.near = this.inputs.select('near');
-        this.far = this.inputs.select('far');
-        this.length = computed(() => new THREE.Vector3(...this.position()).length());
-        this.shadowsApi = injectNgtsAccumulativeShadowsApi();
-        this.amount = this.inputs.select('amount');
-        this.castShadow = this.inputs.select('castShadow');
-        this.intensity = this.inputs.select('intensity');
-        this.bias = this.inputs.select('bias');
-        this.shadowsMapSize = computed(() => [this.mapSize(), this.mapSize()]);
-        this.cameraArgs = computed(() => [-this.size(), this.size(), this.size(), -this.size(), this.near(), this.far()]);
-        this.api = computed(() => {
-            const [lights, ambient, radius, length, position] = [
-                this.lightsRef.nativeElement,
-                this.ambient(),
-                this.radius(),
-                this.length(),
-                this.position(),
-            ];
-            const update = () => {
-                if (lights) {
-                    for (let l = 0; l < lights.children.length; l++) {
-                        const light = lights.children[l];
-                        if (Math.random() > ambient) {
-                            light.position.set(position[0] + THREE.MathUtils.randFloatSpread(radius), position[1] + THREE.MathUtils.randFloatSpread(radius), position[2] + THREE.MathUtils.randFloatSpread(radius));
-                        }
-                        else {
-                            const lambda = Math.acos(2 * Math.random() - 1) - Math.PI / 2.0;
-                            const phi = 2 * Math.PI * Math.random();
-                            light.position.set(Math.cos(lambda) * Math.cos(phi) * length, Math.abs(Math.cos(lambda) * Math.sin(phi) * length), Math.sin(lambda) * length);
-                        }
-                    }
-                }
-            };
-            return { update };
-        });
-        this.updateLightMap();
-    }
-    updateLightMap() {
-        effect((onCleanup) => {
-            const lights = this.lightsRef.nativeElement;
-            if (!lights)
-                return;
-            const shadowsApi = this.shadowsApi();
-            if (shadowsApi) {
-                shadowsApi.lights.set(lights.uuid, this.api);
-                onCleanup(() => shadowsApi.lights.delete(lights.uuid));
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsRandomizedLights, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsRandomizedLights, isStandalone: true, selector: "ngts-randomized-lights", inputs: { lightsRef: "lightsRef", _frames: ["frames", "_frames"], _position: ["position", "_position"], _radius: ["radius", "_radius"], _amount: ["amount", "_amount"], _intensity: ["intensity", "_intensity"], _ambient: ["ambient", "_ambient"], _castShadow: ["castShadow", "_castShadow"], _bias: ["bias", "_bias"], _mapSize: ["mapSize", "_mapSize"], _size: ["size", "_size"], _near: ["near", "_near"], _far: ["far", "_far"] }, ngImport: i0, template: `
-		<ngt-group ngtCompound [ref]="lightsRef">
-			<ngt-directional-light
-				*ngFor="let i; repeat: amount()"
-				[castShadow]="castShadow()"
-				[intensity]="intensity() / amount()"
-			>
-				<ngt-value [rawValue]="bias()" attach="shadow.bias" />
-				<ngt-vector2 *args="shadowsMapSize()" attach="shadow.mapSize" />
-				<ngt-orthographic-camera *args="cameraArgs()" attach="shadow.camera" />
-			</ngt-directional-light>
-			<ng-content />
-		</ngt-group>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtRepeat, selector: "[ngFor][ngForRepeat]", inputs: ["ngForRepeat"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsRandomizedLights, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-randomized-lights',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound [ref]="lightsRef">
-			<ngt-directional-light
-				*ngFor="let i; repeat: amount()"
-				[castShadow]="castShadow()"
-				[intensity]="intensity() / amount()"
-			>
-				<ngt-value [rawValue]="bias()" attach="shadow.bias" />
-				<ngt-vector2 *args="shadowsMapSize()" attach="shadow.mapSize" />
-				<ngt-orthographic-camera *args="cameraArgs()" attach="shadow.camera" />
-			</ngt-directional-light>
-			<ng-content />
-		</ngt-group>
-	`,
-                    imports: [NgtRepeat, NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { lightsRef: [{
-                type: Input
-            }], _frames: [{
-                type: Input,
-                args: [{ alias: 'frames' }]
-            }], _position: [{
-                type: Input,
-                args: [{ alias: 'position' }]
-            }], _radius: [{
-                type: Input,
-                args: [{ alias: 'radius' }]
-            }], _amount: [{
-                type: Input,
-                args: [{ alias: 'amount' }]
-            }], _intensity: [{
-                type: Input,
-                args: [{ alias: 'intensity' }]
-            }], _ambient: [{
-                type: Input,
-                args: [{ alias: 'ambient' }]
-            }], _castShadow: [{
-                type: Input,
-                args: [{ alias: 'castShadow' }]
-            }], _bias: [{
-                type: Input,
-                args: [{ alias: 'bias' }]
-            }], _mapSize: [{
-                type: Input,
-                args: [{ alias: 'mapSize' }]
-            }], _size: [{
-                type: Input,
-                args: [{ alias: 'size' }]
-            }], _near: [{
-                type: Input,
-                args: [{ alias: 'near' }]
-            }], _far: [{
-                type: Input,
-                args: [{ alias: 'far' }]
-            }] } });
-
-const easeInExpo = (x) => (x === 0 ? 0 : Math.pow(2, 10 * x - 10));
-extend({ Group, Mesh, PlaneGeometry });
-class NgtsBackdrop {
-    set _floor(floor) {
-        this.inputs.set({ floor });
-    }
-    set _segments(segments) {
-        this.inputs.set({ segments });
-    }
-    set _receiveShadow(receiveShadow) {
-        this.inputs.set({ receiveShadow });
-    }
-    constructor() {
-        this.Math = Math;
-        this.inputs = signalStore({ floor: 0.25, segments: 20, receiveShadow: false });
-        this.floor = this.inputs.select('floor');
-        this.planeRef = injectNgtRef();
-        this.segments = this.inputs.select('segments');
-        this.receiveShadow = this.inputs.select('receiveShadow');
-        effect(() => {
-            const plane = this.planeRef.nativeElement;
-            if (!plane)
-                return;
-            const [segments, floor] = [this.segments(), this.floor()];
-            const offset = segments / segments / 2;
-            const position = plane.attributes['position'];
-            let i = 0;
-            for (let x = 0; x < segments + 1; x++) {
-                for (let y = 0; y < segments + 1; y++) {
-                    position.setXYZ(i++, x / segments - offset + (x === 0 ? -floor : 0), y / segments - offset, easeInExpo(x / segments));
-                }
-            }
-            checkUpdate(position);
-            plane.computeVertexNormals();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsBackdrop, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsBackdrop, isStandalone: true, selector: "ngts-backdrop", inputs: { _floor: ["floor", "_floor"], _segments: ["segments", "_segments"], _receiveShadow: ["receiveShadow", "_receiveShadow"] }, ngImport: i0, template: `
-		<ngt-group ngtCompound>
-			<ngt-mesh [receiveShadow]="receiveShadow()" [rotation]="[-Math.PI / 2, 0, Math.PI / 2]">
-				<ngt-plane-geometry [ref]="planeRef" *args="[1, 1, segments(), segments()]" />
-				<ng-content />
-			</ngt-mesh>
-		</ngt-group>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsBackdrop, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-backdrop',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound>
-			<ngt-mesh [receiveShadow]="receiveShadow()" [rotation]="[-Math.PI / 2, 0, Math.PI / 2]">
-				<ngt-plane-geometry [ref]="planeRef" *args="[1, 1, segments(), segments()]" />
-				<ng-content />
-			</ngt-mesh>
-		</ngt-group>
-	`,
-                    imports: [NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { _floor: [{
-                type: Input,
-                args: [{ alias: 'floor' }]
-            }], _segments: [{
-                type: Input,
-                args: [{ alias: 'segments' }]
-            }], _receiveShadow: [{
-                type: Input,
-                args: [{ alias: 'receiveShadow' }]
-            }] } });
-
-const boundingBox = new THREE.Box3();
-const boundingBoxSize = new THREE.Vector3();
-extend({ Group });
-class NgtsBBAnchor {
-    set _anchor(anchor) {
-        this.inputs.set({ anchor });
-    }
-    constructor() {
-        this.inputs = signalStore();
-        this.groupRef = injectNgtRef();
-        this.parentRef = injectNgtRef();
-        this.anchor = this.inputs.select('anchor');
-        this.xyz = computed(() => {
-            const anchor = this.anchor();
-            return Array.isArray(anchor) ? anchor : [anchor.x, anchor.y, anchor.z];
-        });
-        this.reattachParent();
-        this.beforeRender();
-    }
-    reattachParent() {
-        effect(() => {
-            const group = this.groupRef.nativeElement;
-            if (!group)
-                return;
-            if (group.parent?.parent) {
-                this.parentRef.nativeElement = group.parent.parent;
-                group.parent.parent.add(group);
-            }
-        });
-    }
-    beforeRender() {
-        injectBeforeRender(() => {
-            const [parent, group, anchor] = [this.parentRef.nativeElement, this.groupRef.nativeElement, this.xyz()];
-            if (parent) {
-                boundingBox.setFromObject(parent);
-                boundingBox.getSize(boundingBoxSize);
-                group.position.set(parent.position.x + (boundingBoxSize.x * anchor[0]) / 2, parent.position.y + (boundingBoxSize.y * anchor[1]) / 2, parent.position.z + (boundingBoxSize.z * anchor[2]) / 2);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsBBAnchor, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsBBAnchor, isStandalone: true, selector: "ngts-bb-anchor", inputs: { _anchor: ["anchor", "_anchor"] }, ngImport: i0, template: `
-		<ngt-group ngtCompound [ref]="groupRef">
-			<ng-content />
-		</ngt-group>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsBBAnchor, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-bb-anchor',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound [ref]="groupRef">
-			<ng-content />
-		</ngt-group>
-	`,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { _anchor: [{
-                type: Input,
-                args: [{ required: true, alias: 'anchor' }]
-            }] } });
-
-extend({ Group });
-const isBox3 = (def) => def && def.isBox3;
-function equals(a, b, eps) {
-    return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps && Math.abs(a.z - b.z) < eps;
-}
-function damp(v, t, lambda, delta) {
-    v.x = THREE.MathUtils.damp(v.x, t.x, lambda, delta);
-    v.y = THREE.MathUtils.damp(v.y, t.y, lambda, delta);
-    v.z = THREE.MathUtils.damp(v.z, t.z, lambda, delta);
-}
-const [injectNgtsBoundsApi, provideNgtsBoundsApi] = createInjectionToken((bounds) => bounds.api, {
-    isRoot: false,
-    deps: [forwardRef(() => NgtsBounds)],
-});
-class NgtsBounds {
-    set _damping(damping) {
-        this.inputs.set({ damping });
-    }
-    set _fit(fit) {
-        this.inputs.set({ fit });
-    }
-    set _clip(clip) {
-        this.inputs.set({ clip });
-    }
-    set _observe(observe) {
-        this.inputs.set({ observe });
-    }
-    set _margin(margin) {
-        this.inputs.set({ margin });
-    }
-    set _eps(eps) {
-        this.inputs.set({ eps });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            damping: 6,
-            fit: false,
-            clip: false,
-            observe: false,
-            margin: 1.2,
-            eps: 0.01,
-        });
-        this.boundsRef = injectNgtRef();
-        this.fitted = new EventEmitter();
-        this.store = injectNgtStore();
-        this.controls = this.store.select('controls');
-        this.size = this.store.select('size');
-        this.camera = this.store.select('camera');
-        this.invalidate = this.store.select('invalidate');
-        this.fit = this.inputs.select('fit');
-        this.clip = this.inputs.select('clip');
-        this.observe = this.inputs.select('observe');
-        this.margin = this.inputs.select('margin');
-        this.damping = this.inputs.select('damping');
-        this.current = { animating: false, focus: new THREE.Vector3(), camera: new THREE.Vector3(), zoom: 1 };
-        this.goal = { focus: new THREE.Vector3(), camera: new THREE.Vector3(), zoom: 1 };
-        this.box = new THREE.Box3();
-        this.api = computed(() => {
-            const { box, boundsRef, current, goal, fitted } = this;
-            const [camera, margin, controls, invalidate, damping] = [
-                this.camera(),
-                this.margin(),
-                this.controls(),
-                this.invalidate(),
-                this.damping(),
-            ];
-            function getSize() {
-                const size = box.getSize(new THREE.Vector3());
-                const center = box.getCenter(new THREE.Vector3());
-                const maxSize = Math.max(size.x, size.y, size.z);
-                const fitHeightDistance = is.orthographicCamera(camera)
-                    ? maxSize * 4
-                    : maxSize / (2 * Math.atan((Math.PI * camera.fov) / 360));
-                const fitWidthDistance = is.orthographicCamera(camera) ? maxSize * 4 : fitHeightDistance / camera.aspect;
-                const distance = margin * Math.max(fitHeightDistance, fitWidthDistance);
-                return { box, size, center, distance };
-            }
-            return {
-                getSize,
-                refresh(object) {
-                    if (isBox3(object))
-                        box.copy(object);
-                    else {
-                        const target = object || boundsRef.nativeElement;
-                        if (!target)
-                            return this;
-                        target.updateWorldMatrix(true, true);
-                        box.setFromObject(target);
-                    }
-                    if (box.isEmpty()) {
-                        const max = camera.position.length() || 10;
-                        box.setFromCenterAndSize(new THREE.Vector3(), new THREE.Vector3(max, max, max));
-                    }
-                    if (controls?.constructor.name === 'OrthographicTrackballControls') {
-                        // Put camera on a sphere along which it should move
-                        const { distance } = getSize();
-                        const direction = camera.position.clone().sub(controls.target).normalize().multiplyScalar(distance);
-                        const newPos = controls.target.clone().add(direction);
-                        camera.position.copy(newPos);
-                    }
-                    return this;
-                },
-                clip() {
-                    const { distance } = getSize();
-                    if (controls)
-                        controls.maxDistance = distance * 10;
-                    camera.near = distance / 100;
-                    camera.far = distance * 100;
-                    camera.updateProjectionMatrix();
-                    if (controls)
-                        controls.update();
-                    invalidate();
-                    return this;
-                },
-                to({ position, target }) {
-                    current.camera.copy(camera.position);
-                    const { center } = getSize();
-                    goal.camera.set(...position);
-                    if (target) {
-                        goal.focus.set(...target);
-                    }
-                    else {
-                        goal.focus.copy(center);
-                    }
-                    if (damping) {
-                        current.animating = true;
-                    }
-                    else {
-                        camera.position.set(...position);
-                    }
-                    return this;
-                },
-                fit() {
-                    current.camera.copy(camera.position);
-                    if (controls)
-                        current.focus.copy(controls.target);
-                    const { center, distance } = getSize();
-                    const direction = center.clone().sub(camera.position).normalize().multiplyScalar(distance);
-                    goal.camera.copy(center).sub(direction);
-                    goal.focus.copy(center);
-                    if (is.orthographicCamera(camera)) {
-                        current.zoom = camera.zoom;
-                        let maxHeight = 0, maxWidth = 0;
-                        const vertices = [
-                            new THREE.Vector3(box.min.x, box.min.y, box.min.z),
-                            new THREE.Vector3(box.min.x, box.max.y, box.min.z),
-                            new THREE.Vector3(box.min.x, box.min.y, box.max.z),
-                            new THREE.Vector3(box.min.x, box.max.y, box.max.z),
-                            new THREE.Vector3(box.max.x, box.max.y, box.max.z),
-                            new THREE.Vector3(box.max.x, box.max.y, box.min.z),
-                            new THREE.Vector3(box.max.x, box.min.y, box.max.z),
-                            new THREE.Vector3(box.max.x, box.min.y, box.min.z),
-                        ];
-                        // Transform the center and each corner to camera space
-                        center.applyMatrix4(camera.matrixWorldInverse);
-                        for (const v of vertices) {
-                            v.applyMatrix4(camera.matrixWorldInverse);
-                            maxHeight = Math.max(maxHeight, Math.abs(v.y - center.y));
-                            maxWidth = Math.max(maxWidth, Math.abs(v.x - center.x));
-                        }
-                        maxHeight *= 2;
-                        maxWidth *= 2;
-                        const zoomForHeight = (camera.top - camera.bottom) / maxHeight;
-                        const zoomForWidth = (camera.right - camera.left) / maxWidth;
-                        goal.zoom = Math.min(zoomForHeight, zoomForWidth) / margin;
-                        if (!damping) {
-                            camera.zoom = goal.zoom;
-                            camera.updateProjectionMatrix();
-                        }
-                    }
-                    if (damping) {
-                        current.animating = true;
-                    }
-                    else {
-                        camera.position.copy(goal.camera);
-                        camera.lookAt(goal.focus);
-                        if (controls) {
-                            controls.target.copy(goal.focus);
-                            controls.update();
-                        }
-                    }
-                    if (fitted.observed) {
-                        fitted.emit(this.getSize());
-                    }
-                    invalidate();
-                    return this;
-                },
-            };
-        });
-        this.preventDragHijacking();
-        this.scalePointer();
-        this.beforeRender();
-    }
-    preventDragHijacking() {
-        effect((onCleanup) => {
-            const controls = this.controls();
-            if (controls) {
-                const callback = () => (this.current.animating = false);
-                controls.addEventListener('start', callback);
-                onCleanup(() => controls.removeEventListener('start', callback));
-            }
-        });
-    }
-    scalePointer() {
-        let count = 0;
-        effect(() => {
-            const [observe, fit, clip, api] = [
-                this.observe(),
-                this.fit(),
-                this.clip(),
-                untracked(this.api),
-                this.camera(),
-                this.controls(),
-                this.size(),
-            ];
-            if (observe || count++ === 0) {
-                api.refresh();
-                if (fit)
-                    api.fit();
-                if (clip)
-                    api.clip();
-            }
-        });
-    }
-    beforeRender() {
-        injectBeforeRender(({ delta }) => {
-            const [{ damping, eps }, camera, controls, invalidate] = [
-                this.inputs.get(),
-                this.camera(),
-                this.controls(),
-                this.invalidate(),
-            ];
-            if (this.current.animating) {
-                damp(this.current.focus, this.goal.focus, damping, delta);
-                damp(this.current.camera, this.goal.camera, damping, delta);
-                this.current.zoom = THREE.MathUtils.damp(this.current.zoom, this.goal.zoom, damping, delta);
-                camera.position.copy(this.current.camera);
-                if (is.orthographicCamera(camera)) {
-                    camera.zoom = this.current.zoom;
-                    camera.updateProjectionMatrix();
-                }
-                if (!controls) {
-                    camera.lookAt(this.current.focus);
-                }
-                else {
-                    controls.target.copy(this.current.focus);
-                    controls.update();
-                }
-                invalidate();
-                if (is.orthographicCamera(camera) && !(Math.abs(this.current.zoom - this.goal.zoom) < eps))
-                    return;
-                if (!is.orthographicCamera(camera) && !equals(this.current.camera, this.goal.camera, eps))
-                    return;
-                if (controls && !equals(this.current.focus, this.goal.focus, eps))
-                    return;
-                this.current.animating = false;
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsBounds, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsBounds, isStandalone: true, selector: "ngts-bounds", inputs: { boundsRef: "boundsRef", _damping: ["damping", "_damping"], _fit: ["fit", "_fit"], _clip: ["clip", "_clip"], _observe: ["observe", "_observe"], _margin: ["margin", "_margin"], _eps: ["eps", "_eps"] }, outputs: { fitted: "fitted" }, providers: [provideNgtsBoundsApi()], ngImport: i0, template: `
-		<ngt-group [ref]="boundsRef">
-			<ng-content />
-		</ngt-group>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsBounds, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-bounds',
-                    standalone: true,
-                    template: `
-		<ngt-group [ref]="boundsRef">
-			<ng-content />
-		</ngt-group>
-	`,
-                    providers: [provideNgtsBoundsApi()],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { boundsRef: [{
-                type: Input
-            }], _damping: [{
-                type: Input,
-                args: [{ alias: 'damping' }]
-            }], _fit: [{
-                type: Input,
-                args: [{ alias: 'fit' }]
-            }], _clip: [{
-                type: Input,
-                args: [{ alias: 'clip' }]
-            }], _observe: [{
-                type: Input,
-                args: [{ alias: 'observe' }]
-            }], _margin: [{
-                type: Input,
-                args: [{ alias: 'margin' }]
-            }], _eps: [{
-                type: Input,
-                args: [{ alias: 'eps' }]
-            }], fitted: [{
-                type: Output
-            }] } });
-
-class NgtsCameraShake {
-    set _intensity(intensity) {
-        this.inputs.set({ intensity });
-    }
-    set _decay(decay) {
-        this.inputs.set({ decay });
-    }
-    set _decayRate(decayRate) {
-        this.inputs.set({ decayRate });
-    }
-    set _maxYaw(maxYaw) {
-        this.inputs.set({ maxYaw });
-    }
-    set _maxPitch(maxPitch) {
-        this.inputs.set({ maxPitch });
-    }
-    set _maxRoll(maxRoll) {
-        this.inputs.set({ maxRoll });
-    }
-    set _yawFrequency(yawFrequency) {
-        this.inputs.set({ yawFrequency });
-    }
-    set _pitchFrequency(pitchFrequency) {
-        this.inputs.set({ pitchFrequency });
-    }
-    set _rollFrequency(rollFrequency) {
-        this.inputs.set({ rollFrequency });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            intensity: 1,
-            decayRate: 0.65,
-            maxYaw: 0.1,
-            maxPitch: 0.1,
-            maxRoll: 0.1,
-            yawFrequency: 0.1,
-            pitchFrequency: 0.1,
-            rollFrequency: 0.1,
-        });
-        this.store = injectNgtStore();
-        this.camera = this.store.select('camera');
-        this.controls = this.store.select('controls');
-        this.initialRotation = this.store.get('camera').rotation.clone();
-        this.yawNoise = new SimplexNoise();
-        this.rollNoise = new SimplexNoise();
-        this.pitchNoise = new SimplexNoise();
-        this.intensity = this.inputs.select('intensity');
-        this.constrainedIntensity = computed(() => {
-            const intensity = this.intensity();
-            if (intensity < 0 || intensity > 1) {
-                return intensity < 0 ? 0 : 1;
-            }
-            return intensity;
-        });
-        this.beforeRender();
-        this.setEvents();
-    }
-    beforeRender() {
-        injectBeforeRender(({ clock, delta }) => {
-            const [{ maxYaw, yawFrequency, maxPitch, pitchFrequency, maxRoll, rollFrequency, decay, decayRate }, intensity, camera,] = [this.inputs.get(), this.constrainedIntensity(), this.camera()];
-            const shake = Math.pow(intensity, 2);
-            const yaw = maxYaw * shake * this.yawNoise.noise(clock.elapsedTime * yawFrequency, 1);
-            const pitch = maxPitch * shake * this.pitchNoise.noise(clock.elapsedTime * pitchFrequency, 1);
-            const roll = maxRoll * shake * this.rollNoise.noise(clock.elapsedTime * rollFrequency, 1);
-            camera.rotation.set(this.initialRotation.x + pitch, this.initialRotation.y + yaw, this.initialRotation.z + roll);
-            if (decay && intensity > 0) {
-                this.inputs.set((state) => ({ intensity: state.intensity - decayRate * delta }));
-            }
-        });
-    }
-    setEvents() {
-        effect((onCleanup) => {
-            const [camera, controls] = [this.camera(), this.controls()];
-            if (controls) {
-                const callback = () => void (this.initialRotation = camera.rotation.clone());
-                controls.addEventListener('change', callback);
-                callback();
-                onCleanup(() => void controls.removeEventListener('change', callback));
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsCameraShake, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsCameraShake, isStandalone: true, selector: "ngts-camera-shake", inputs: { _intensity: ["intensity", "_intensity"], _decay: ["decay", "_decay"], _decayRate: ["decayRate", "_decayRate"], _maxYaw: ["maxYaw", "_maxYaw"], _maxPitch: ["maxPitch", "_maxPitch"], _maxRoll: ["maxRoll", "_maxRoll"], _yawFrequency: ["yawFrequency", "_yawFrequency"], _pitchFrequency: ["pitchFrequency", "_pitchFrequency"], _rollFrequency: ["rollFrequency", "_rollFrequency"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsCameraShake, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'ngts-camera-shake',
-                    standalone: true,
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { _intensity: [{
-                type: Input,
-                args: [{ alias: 'intensity' }]
-            }], _decay: [{
-                type: Input,
-                args: [{ alias: 'decay' }]
-            }], _decayRate: [{
-                type: Input,
-                args: [{ alias: 'decayRate' }]
-            }], _maxYaw: [{
-                type: Input,
-                args: [{ alias: 'maxYaw' }]
-            }], _maxPitch: [{
-                type: Input,
-                args: [{ alias: 'maxPitch' }]
-            }], _maxRoll: [{
-                type: Input,
-                args: [{ alias: 'maxRoll' }]
-            }], _yawFrequency: [{
-                type: Input,
-                args: [{ alias: 'yawFrequency' }]
-            }], _pitchFrequency: [{
-                type: Input,
-                args: [{ alias: 'pitchFrequency' }]
-            }], _rollFrequency: [{
-                type: Input,
-                args: [{ alias: 'rollFrequency' }]
-            }] } });
-
-extend({ Group });
-class NgtsCenter {
-    set _top(top) {
-        this.inputs.set({ top });
-    }
-    set _right(right) {
-        this.inputs.set({ right });
-    }
-    set _bottom(bottom) {
-        this.inputs.set({ bottom });
-    }
-    set _left(left) {
-        this.inputs.set({ left });
-    }
-    set _front(front) {
-        this.inputs.set({ front });
-    }
-    set _back(back) {
-        this.inputs.set({ back });
-    }
-    set _disableX(disableX) {
-        this.inputs.set({ disableX });
-    }
-    set _disableY(disableY) {
-        this.inputs.set({ disableY });
-    }
-    set _disableZ(disableZ) {
-        this.inputs.set({ disableZ });
-    }
-    set _disable(disable) {
-        this.inputs.set({ disable });
-    }
-    set _precise(precise) {
-        this.inputs.set({ precise });
-    }
-    set _cacheKey(cacheKey) {
-        this.inputs.set({ cacheKey });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            precise: true,
-            cacheKey: 0,
-        });
-        this.centerRef = injectNgtRef();
-        this.outerRef = injectNgtRef();
-        this.innerRef = injectNgtRef();
-        this.centered = new EventEmitter();
-        this.setPosition();
-    }
-    setPosition() {
-        const innerChildren = this.innerRef.children();
-        effect(() => {
-            const [outer, inner, centerRef, { precise, top, bottom, left, front, right, back, disable, disableX, disableY, disableZ },] = [
-                this.outerRef.nativeElement,
-                this.innerRef.nativeElement,
-                this.centerRef.nativeElement,
-                this.inputs.state(),
-                innerChildren(),
-            ];
-            if (outer && inner && centerRef) {
-                outer.matrixWorld.identity();
-                const box3 = new THREE.Box3().setFromObject(inner, precise);
-                const center = new THREE.Vector3();
-                const sphere = new THREE.Sphere();
-                const width = box3.max.x - box3.min.x;
-                const height = box3.max.y - box3.min.y;
-                const depth = box3.max.z - box3.min.z;
-                box3.getCenter(center);
-                box3.getBoundingSphere(sphere);
-                const vAlign = top ? height / 2 : bottom ? -height / 2 : 0;
-                const hAlign = left ? -width / 2 : right ? width / 2 : 0;
-                const dAlign = front ? depth / 2 : back ? -depth / 2 : 0;
-                outer.position.set(disable || disableX ? 0 : -center.x + hAlign, disable || disableY ? 0 : -center.y + vAlign, disable || disableZ ? 0 : -center.z + dAlign);
-                if (this.centered.observed) {
-                    this.centered.emit({
-                        parent: centerRef.parent,
-                        container: centerRef,
-                        width,
-                        height,
-                        depth,
-                        boundingBox: box3,
-                        boundingSphere: sphere,
-                        center: center,
-                        verticalAlignment: vAlign,
-                        horizontalAlignment: hAlign,
-                        depthAlignment: dAlign,
-                    });
-                }
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsCenter, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsCenter, isStandalone: true, selector: "ngts-center", inputs: { centerRef: "centerRef", _top: ["top", "_top"], _right: ["right", "_right"], _bottom: ["bottom", "_bottom"], _left: ["left", "_left"], _front: ["front", "_front"], _back: ["back", "_back"], _disableX: ["disableX", "_disableX"], _disableY: ["disableY", "_disableY"], _disableZ: ["disableZ", "_disableZ"], _disable: ["disable", "_disable"], _precise: ["precise", "_precise"], _cacheKey: ["cacheKey", "_cacheKey"] }, outputs: { centered: "centered" }, ngImport: i0, template: `
-		<ngt-group [ref]="centerRef" ngtCompound>
-			<ngt-group [ref]="outerRef">
-				<ngt-group [ref]="innerRef">
-					<ng-content />
-				</ngt-group>
-			</ngt-group>
-		</ngt-group>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsCenter, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-center',
-                    standalone: true,
-                    template: `
-		<ngt-group [ref]="centerRef" ngtCompound>
-			<ngt-group [ref]="outerRef">
-				<ngt-group [ref]="innerRef">
-					<ng-content />
-				</ngt-group>
-			</ngt-group>
-		</ngt-group>
-	`,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { centerRef: [{
-                type: Input
-            }], _top: [{
-                type: Input,
-                args: [{ alias: 'top' }]
-            }], _right: [{
-                type: Input,
-                args: [{ alias: 'right' }]
-            }], _bottom: [{
-                type: Input,
-                args: [{ alias: 'bottom' }]
-            }], _left: [{
-                type: Input,
-                args: [{ alias: 'left' }]
-            }], _front: [{
-                type: Input,
-                args: [{ alias: 'front' }]
-            }], _back: [{
-                type: Input,
-                args: [{ alias: 'back' }]
-            }], _disableX: [{
-                type: Input,
-                args: [{ alias: 'disableX' }]
-            }], _disableY: [{
-                type: Input,
-                args: [{ alias: 'disableY' }]
-            }], _disableZ: [{
-                type: Input,
-                args: [{ alias: 'disableZ' }]
-            }], _disable: [{
-                type: Input,
-                args: [{ alias: 'disable' }]
-            }], _precise: [{
-                type: Input,
-                args: [{ alias: 'precise' }]
-            }], _cacheKey: [{
-                type: Input,
-                args: [{ alias: 'cacheKey' }]
-            }], centered: [{
-                type: Output
-            }] } });
-
-const CLOUD_URL = 'https://rawcdn.githack.com/pmndrs/drei-assets/9225a9f1fbd449d9411125c2f419b843d0308c9f/cloud.png';
-injectNgtsTextureLoader.preload(() => CLOUD_URL);
-extend({ Group, Mesh, PlaneGeometry, MeshStandardMaterial });
-class NgtsCloud {
-    constructor() {
-        this.inputs = signalStore({
-            opacity: 0.5,
-            speed: 0.4,
-            width: 10,
-            depth: 1.5,
-            segments: 20,
-            texture: CLOUD_URL,
-            color: '#ffffff',
-            depthTest: true,
-        });
-        this.groupRef = injectNgtRef();
-        this.width = this.inputs.select('width');
-        this.speed = this.inputs.select('speed');
-        this.segments = this.inputs.select('segments');
-        this.depth = this.inputs.select('depth');
-        this.depthTest = this.inputs.select('depthTest');
-        this.opacity = this.inputs.select('opacity');
-        this.color = this.inputs.select('color');
-        this.texture = injectNgtsTextureLoader(this.inputs.select('texture'));
-        this.clouds = computed(() => [...new Array(this.segments())].map((_, index) => ({
-            x: this.width() / 2 - Math.random() * this.width(),
-            y: this.width() / 2 - Math.random() * this.width(),
-            scale: 0.4 + Math.sin(((index + 1) / this.segments()) * Math.PI) * ((0.2 + Math.random()) * 10),
-            density: Math.max(0.2, Math.random()),
-            rotation: Math.max(0.002, 0.005 * Math.random()) * this.speed(),
-        })));
-    }
-    set _opacity(opacity) {
-        this.inputs.set({ opacity });
-    }
-    set _speed(speed) {
-        this.inputs.set({ speed });
-    }
-    set _width(width) {
-        this.inputs.set({ width });
-    }
-    set _depth(depth) {
-        this.inputs.set({ depth });
-    }
-    set _segments(segments) {
-        this.inputs.set({ segments });
-    }
-    set _texture(texture) {
-        this.inputs.set({ texture });
-    }
-    set _color(color) {
-        this.inputs.set({ color });
-    }
-    set _depthTest(depthTest) {
-        this.inputs.set({ depthTest });
-    }
-    onBeforeRender({ state, object }) {
-        const clouds = this.clouds();
-        object.children.forEach((cloud, index) => {
-            cloud.children[0].rotation.z += clouds[index].rotation;
-            cloud.children[0].scale.setScalar(clouds[index].scale + (((1 + Math.sin(state.clock.getElapsedTime() / 10)) / 2) * index) / 10);
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsCloud, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsCloud, isStandalone: true, selector: "ngts-cloud", inputs: { groupRef: "groupRef", _opacity: ["opacity", "_opacity"], _speed: ["speed", "_speed"], _width: ["width", "_width"], _depth: ["depth", "_depth"], _segments: ["segments", "_segments"], _texture: ["texture", "_texture"], _color: ["color", "_color"], _depthTest: ["depthTest", "_depthTest"] }, ngImport: i0, template: `
-		<ngt-group ngtCompound>
-			<ngt-group
-				[position]="[0, 0, (segments() / 2) * depth()]"
-				[ref]="groupRef"
-				(beforeRender)="onBeforeRender($event)"
-			>
-				<ngts-billboard
-					*ngFor="let cloud of clouds(); let i = index"
-					[position]="[cloud.x, cloud.y, -i * depth()]"
-				>
-					<ngt-mesh [scale]="cloud.scale" [rotation]="[0, 0, 0]">
-						<ngt-plane-geometry />
-						<ngt-mesh-standard-material
-							[map]="texture()"
-							[transparent]="true"
-							[opacity]="(cloud.scale / 6) * cloud.density * opacity()"
-							[depthTest]="depthTest()"
-							[color]="color()"
-						/>
-					</ngt-mesh>
-				</ngts-billboard>
-			</ngt-group>
-		</ngt-group>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: NgtsBillboard, selector: "ngts-billboard", inputs: ["billboardRef", "follow", "lockX", "lockY", "lockZ"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsCloud, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-cloud',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound>
-			<ngt-group
-				[position]="[0, 0, (segments() / 2) * depth()]"
-				[ref]="groupRef"
-				(beforeRender)="onBeforeRender($event)"
-			>
-				<ngts-billboard
-					*ngFor="let cloud of clouds(); let i = index"
-					[position]="[cloud.x, cloud.y, -i * depth()]"
-				>
-					<ngt-mesh [scale]="cloud.scale" [rotation]="[0, 0, 0]">
-						<ngt-plane-geometry />
-						<ngt-mesh-standard-material
-							[map]="texture()"
-							[transparent]="true"
-							[opacity]="(cloud.scale / 6) * cloud.density * opacity()"
-							[depthTest]="depthTest()"
-							[color]="color()"
-						/>
-					</ngt-mesh>
-				</ngts-billboard>
-			</ngt-group>
-		</ngt-group>
-	`,
-                    imports: [NgFor, NgtsBillboard, NgIf],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], propDecorators: { groupRef: [{
-                type: Input
-            }], _opacity: [{
-                type: Input,
-                args: [{ alias: 'opacity' }]
-            }], _speed: [{
-                type: Input,
-                args: [{ alias: 'speed' }]
-            }], _width: [{
-                type: Input,
-                args: [{ alias: 'width' }]
-            }], _depth: [{
-                type: Input,
-                args: [{ alias: 'depth' }]
-            }], _segments: [{
-                type: Input,
-                args: [{ alias: 'segments' }]
-            }], _texture: [{
-                type: Input,
-                args: [{ alias: 'texture' }]
-            }], _color: [{
-                type: Input,
-                args: [{ alias: 'color' }]
-            }], _depthTest: [{
-                type: Input,
-                args: [{ alias: 'depthTest' }]
-            }] } });
-
-extend({ Group, Mesh, MeshBasicMaterial, OrthographicCamera });
-class NgtsContactShadows {
-    set _opacity(opacity) {
-        this.inputs.set({ opacity });
-    }
-    set _width(width) {
-        this.inputs.set({ width });
-    }
-    set _height(height) {
-        this.inputs.set({ height });
-    }
-    set _blur(blur) {
-        this.inputs.set({ blur });
-    }
-    set _far(far) {
-        this.inputs.set({ far });
-    }
-    set _smooth(smooth) {
-        this.inputs.set({ smooth });
-    }
-    set _resolution(resolution) {
-        this.inputs.set({ resolution });
-    }
-    set _frames(frames) {
-        this.inputs.set({ frames });
-    }
-    set _scale(scale) {
-        this.inputs.set({ scale });
-    }
-    set _color(color) {
-        this.inputs.set({ color });
-    }
-    set _depthWrite(depthWrite) {
-        this.inputs.set({ depthWrite });
-    }
-    set _renderOrder(renderOrder) {
-        this.inputs.set({ renderOrder });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            scale: 10,
-            frames: Infinity,
-            opacity: 1,
-            width: 1,
-            height: 1,
-            blur: 1,
-            far: 10,
-            resolution: 512,
-            smooth: true,
-            color: '#000000',
-            depthWrite: false,
-            renderOrder: 0,
-        });
-        this.contactShadowsRef = injectNgtRef();
-        this.Math = Math;
-        this.store = injectNgtStore();
-        this.shadowCameraRef = injectNgtRef();
-        this.scale = this.inputs.select('scale');
-        this.width = this.inputs.select('width');
-        this.height = this.inputs.select('height');
-        this.far = this.inputs.select('far');
-        this.resolution = this.inputs.select('resolution');
-        this.color = this.inputs.select('color');
-        this.scaledWidth = computed(() => {
-            const scale = this.scale();
-            return this.width() * (Array.isArray(scale) ? scale[0] : scale || 1);
-        });
-        this.scaledHeight = computed(() => {
-            const scale = this.scale();
-            return this.height() * (Array.isArray(scale) ? scale[1] : scale || 1);
-        });
-        this.renderOrder = this.inputs.select('renderOrder');
-        this.opacity = this.inputs.select('opacity');
-        this.depthWrite = this.inputs.select('depthWrite');
-        this.cameraArgs = computed(() => {
-            const width = this.scaledWidth();
-            const height = this.scaledHeight();
-            return [-width / 2, width / 2, height / 2, -height / 2, 0, this.far()];
-        });
-        this.contactShadows = computed(() => {
-            const color = this.color();
-            const resolution = this.resolution();
-            const renderTarget = new THREE.WebGLRenderTarget(resolution, resolution);
-            const renderTargetBlur = new THREE.WebGLRenderTarget(resolution, resolution);
-            renderTargetBlur.texture.generateMipmaps = renderTarget.texture.generateMipmaps = false;
-            const planeGeometry = new THREE.PlaneGeometry(this.scaledWidth(), this.scaledHeight()).rotateX(Math.PI / 2);
-            const blurPlane = new Mesh(planeGeometry);
-            const depthMaterial = new THREE.MeshDepthMaterial();
-            depthMaterial.depthTest = depthMaterial.depthWrite = false;
-            depthMaterial.onBeforeCompile = (shader) => {
-                shader.uniforms = {
-                    ...shader.uniforms,
-                    ucolor: { value: new THREE.Color(color) },
-                };
-                shader.fragmentShader = shader.fragmentShader.replace(`void main() {`, //
-                `uniform vec3 ucolor;
-                 void main() {
-                `);
-                shader.fragmentShader = shader.fragmentShader.replace('vec4( vec3( 1.0 - fragCoordZ ), opacity );', 
-                // Colorize the shadow, multiply by the falloff so that the center can remain darker
-                'vec4( ucolor * fragCoordZ * 2.0, ( 1.0 - fragCoordZ ) * 1.0 );');
-            };
-            const horizontalBlurMaterial = new THREE.ShaderMaterial(HorizontalBlurShader);
-            const verticalBlurMaterial = new THREE.ShaderMaterial(VerticalBlurShader);
-            verticalBlurMaterial.depthTest = horizontalBlurMaterial.depthTest = false;
-            return {
-                renderTarget,
-                planeGeometry,
-                depthMaterial,
-                blurPlane,
-                horizontalBlurMaterial,
-                verticalBlurMaterial,
-                renderTargetBlur,
-            };
-        });
-        injectBeforeRender(this.beforeRender.bind(this, 0));
-    }
-    beforeRender(count, { scene, gl }) {
-        const { frames = Infinity, blur = 1, smooth = true } = this.inputs.get();
-        const { depthMaterial, renderTarget } = this.contactShadows();
-        const shadowCamera = this.shadowCameraRef.nativeElement;
-        if (shadowCamera && (frames === Infinity || count < frames)) {
-            const initialBackground = scene.background;
-            scene.background = null;
-            const initialOverrideMaterial = scene.overrideMaterial;
-            scene.overrideMaterial = depthMaterial;
-            gl.setRenderTarget(renderTarget);
-            gl.render(scene, shadowCamera);
-            scene.overrideMaterial = initialOverrideMaterial;
-            this.blurShadows(blur);
-            if (smooth)
-                this.blurShadows(blur * 0.4);
-            gl.setRenderTarget(null);
-            scene.background = initialBackground;
-            count++;
-        }
-    }
-    blurShadows(blur) {
-        const { blurPlane, horizontalBlurMaterial, verticalBlurMaterial, renderTargetBlur, renderTarget } = this.contactShadows();
-        const gl = this.store.get('gl');
-        const shadowCamera = this.shadowCameraRef.nativeElement;
-        blurPlane.visible = true;
-        blurPlane.material = horizontalBlurMaterial;
-        horizontalBlurMaterial.uniforms['tDiffuse'].value = renderTarget.texture;
-        horizontalBlurMaterial.uniforms['h'].value = (blur * 1) / 256;
-        gl.setRenderTarget(renderTargetBlur);
-        gl.render(blurPlane, shadowCamera);
-        blurPlane.material = verticalBlurMaterial;
-        verticalBlurMaterial.uniforms['tDiffuse'].value = renderTargetBlur.texture;
-        verticalBlurMaterial.uniforms['v'].value = (blur * 1) / 256;
-        gl.setRenderTarget(renderTarget);
-        gl.render(blurPlane, shadowCamera);
-        blurPlane.visible = false;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsContactShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsContactShadows, isStandalone: true, selector: "ngts-contact-shadows", inputs: { contactShadowsRef: "contactShadowsRef", _opacity: ["opacity", "_opacity"], _width: ["width", "_width"], _height: ["height", "_height"], _blur: ["blur", "_blur"], _far: ["far", "_far"], _smooth: ["smooth", "_smooth"], _resolution: ["resolution", "_resolution"], _frames: ["frames", "_frames"], _scale: ["scale", "_scale"], _color: ["color", "_color"], _depthWrite: ["depthWrite", "_depthWrite"], _renderOrder: ["renderOrder", "_renderOrder"] }, ngImport: i0, template: `
-		<ngt-group ngtCompound [ref]="contactShadowsRef" [rotation]="[Math.PI / 2, 0, 0]">
-			<ngt-mesh
-				[renderOrder]="renderOrder() ?? 0"
-				[geometry]="contactShadows().planeGeometry"
-				[scale]="[1, -1, 1]"
-				[rotation]="[-Math.PI / 2, 0, 0]"
-			>
-				<ngt-mesh-basic-material
-					[map]="contactShadows().renderTarget.texture"
-					[transparent]="true"
-					[opacity]="opacity() ?? 1"
-					[depthWrite]="depthWrite() ?? false"
-				/>
-			</ngt-mesh>
-			<ngt-orthographic-camera *args="cameraArgs()" [ref]="shadowCameraRef" />
-		</ngt-group>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsContactShadows, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-contact-shadows',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound [ref]="contactShadowsRef" [rotation]="[Math.PI / 2, 0, 0]">
-			<ngt-mesh
-				[renderOrder]="renderOrder() ?? 0"
-				[geometry]="contactShadows().planeGeometry"
-				[scale]="[1, -1, 1]"
-				[rotation]="[-Math.PI / 2, 0, 0]"
-			>
-				<ngt-mesh-basic-material
-					[map]="contactShadows().renderTarget.texture"
-					[transparent]="true"
-					[opacity]="opacity() ?? 1"
-					[depthWrite]="depthWrite() ?? false"
-				/>
-			</ngt-mesh>
-			<ngt-orthographic-camera *args="cameraArgs()" [ref]="shadowCameraRef" />
-		</ngt-group>
-	`,
-                    imports: [NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { contactShadowsRef: [{
-                type: Input
-            }], _opacity: [{
-                type: Input,
-                args: [{ alias: 'opacity' }]
-            }], _width: [{
-                type: Input,
-                args: [{ alias: 'width' }]
-            }], _height: [{
-                type: Input,
-                args: [{ alias: 'height' }]
-            }], _blur: [{
-                type: Input,
-                args: [{ alias: 'blur' }]
-            }], _far: [{
-                type: Input,
-                args: [{ alias: 'far' }]
-            }], _smooth: [{
-                type: Input,
-                args: [{ alias: 'smooth' }]
-            }], _resolution: [{
-                type: Input,
-                args: [{ alias: 'resolution' }]
-            }], _frames: [{
-                type: Input,
-                args: [{ alias: 'frames' }]
-            }], _scale: [{
-                type: Input,
-                args: [{ alias: 'scale' }]
-            }], _color: [{
-                type: Input,
-                args: [{ alias: 'color' }]
-            }], _depthWrite: [{
-                type: Input,
-                args: [{ alias: 'depthWrite' }]
-            }], _renderOrder: [{
-                type: Input,
-                args: [{ alias: 'renderOrder' }]
-            }] } });
-
-const ENVIRONMENT_PRESETS = {
-    apartment: 'lebombo_1k.hdr',
-    city: 'potsdamer_platz_1k.hdr',
-    dawn: 'kiara_1_dawn_1k.hdr',
-    forest: 'forest_slope_1k.hdr',
-    lobby: 'st_fagans_interior_1k.hdr',
-    night: 'dikhololo_night_1k.hdr',
-    park: 'rooitou_park_1k.hdr',
-    studio: 'studio_small_03_1k.hdr',
-    sunset: 'venice_sunset_1k.hdr',
-    warehouse: 'empty_warehouse_01_1k.hdr',
-};
-
-class NgtsEnvironmentInput {
-    constructor() {
-        this.inputs = signalStore({});
-        this.frames = this.inputs.select('frames');
-        this.near = this.inputs.select('near');
-        this.far = this.inputs.select('far');
-        this.resolution = this.inputs.select('resolution');
-        this.background = this.inputs.select('background');
-        this.blur = this.inputs.select('blur');
-        this.map = this.inputs.select('map');
-        this.files = this.inputs.select('files');
-        this.path = this.inputs.select('path');
-        this.preset = this.inputs.select('preset');
-        this.scene = this.inputs.select('scene');
-        this.extensions = this.inputs.select('extensions');
-        this.ground = this.inputs.select('ground');
-        this.encoding = this.inputs.select('encoding');
-        this.params = computed(() => ({
-            files: this.files(),
-            path: this.path(),
-            preset: this.preset(),
-            extensions: this.extensions(),
-            encoding: this.encoding(),
-        }));
-    }
-    set _frames(frames) {
-        this.inputs.set({ frames });
-    }
-    set _near(near) {
-        this.inputs.set({ near });
-    }
-    set _far(far) {
-        this.inputs.set({ far });
-    }
-    set _resolution(resolution) {
-        this.inputs.set({ resolution });
-    }
-    set _background(background) {
-        this.inputs.set({ background });
-    }
-    set _blur(blur) {
-        this.inputs.set({ blur });
-    }
-    set _map(map) {
-        this.inputs.set({ map });
-    }
-    set _files(files) {
-        this.inputs.set({ files });
-    }
-    set _path(path) {
-        this.inputs.set({ path });
-    }
-    set _preset(preset) {
-        this.inputs.set({ preset });
-    }
-    set _scene(scene) {
-        this.inputs.set({ scene });
-    }
-    set _extensions(extensions) {
-        this.inputs.set({ extensions });
-    }
-    set _ground(ground) {
-        this.inputs.set({ ground });
-    }
-    set _encoding(encoding) {
-        this.inputs.set({ encoding });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsEnvironmentInput, inputs: { _frames: ["frames", "_frames"], _near: ["near", "_near"], _far: ["far", "_far"], _resolution: ["resolution", "_resolution"], _background: ["background", "_background"], _blur: ["blur", "_blur"], _map: ["map", "_map"], _files: ["files", "_files"], _path: ["path", "_path"], _preset: ["preset", "_preset"], _scene: ["scene", "_scene"], _extensions: ["extensions", "_extensions"], _ground: ["ground", "_ground"], _encoding: ["encoding", "_encoding"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentInput, decorators: [{
-            type: Directive
-        }], propDecorators: { _frames: [{
-                type: Input,
-                args: [{ alias: 'frames' }]
-            }], _near: [{
-                type: Input,
-                args: [{ alias: 'near' }]
-            }], _far: [{
-                type: Input,
-                args: [{ alias: 'far' }]
-            }], _resolution: [{
-                type: Input,
-                args: [{ alias: 'resolution' }]
-            }], _background: [{
-                type: Input,
-                args: [{ alias: 'background' }]
-            }], _blur: [{
-                type: Input,
-                args: [{ alias: 'blur' }]
-            }], _map: [{
-                type: Input,
-                args: [{ alias: 'map' }]
-            }], _files: [{
-                type: Input,
-                args: [{ alias: 'files' }]
-            }], _path: [{
-                type: Input,
-                args: [{ alias: 'path' }]
-            }], _preset: [{
-                type: Input,
-                args: [{ alias: 'preset' }]
-            }], _scene: [{
-                type: Input,
-                args: [{ alias: 'scene' }]
-            }], _extensions: [{
-                type: Input,
-                args: [{ alias: 'extensions' }]
-            }], _ground: [{
-                type: Input,
-                args: [{ alias: 'ground' }]
-            }], _encoding: [{
-                type: Input,
-                args: [{ alias: 'encoding' }]
-            }] } });
-
-function resolveScene(scene) {
-    return is.ref(scene) ? scene.nativeElement : scene;
-}
-function setEnvProps(background, scene, defaultScene, texture, blur = 0) {
-    const target = resolveScene(scene || defaultScene);
-    const oldbg = target.background;
-    const oldenv = target.environment;
-    const oldBlur = target.backgroundBlurriness || 0;
-    if (background !== 'only')
-        target.environment = texture;
-    if (background)
-        target.background = texture;
-    if (background && target.backgroundBlurriness !== undefined)
-        target.backgroundBlurriness = blur;
-    return () => {
-        if (background !== 'only')
-            target.environment = oldenv;
-        if (background)
-            target.background = oldbg;
-        if (background && target.backgroundBlurriness !== undefined)
-            target.backgroundBlurriness = oldBlur;
-    };
-}
-const CUBEMAP_ROOT = 'https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/';
-function injectNgtsEnvironment(paramsFactory, injector) {
-    injector = assertInjectionContext(injectNgtsEnvironment, injector);
-    return runInInjectionContext(injector, () => {
-        const textureRef = injectNgtRef();
-        const cdr = inject(ChangeDetectorRef);
-        inject(DestroyRef).onDestroy(() => {
-            textureRef.nativeElement.dispose();
-        });
-        const params = computed(() => {
-            let { files, preset, encoding, path, extensions } = paramsFactory();
-            if (files == null) {
-                files = ['/px.png', '/nx.png', '/py.png', '/ny.png', '/pz.png', '/nz.png'];
-            }
-            if (path == null) {
-                path = '';
-            }
-            if (preset) {
-                if (!(preset in ENVIRONMENT_PRESETS))
-                    throw new Error('Preset must be one of: ' + Object.keys(ENVIRONMENT_PRESETS).join(', '));
-                files = ENVIRONMENT_PRESETS[preset];
-                path = CUBEMAP_ROOT;
-            }
-            return { files, preset, encoding, path, extensions };
-        });
-        const loaderResult = injectNgtLoader(
-        // @ts-expect-error
-        () => {
-            const { files = '' } = params();
-            const isCubeMap = Array.isArray(files);
-            const extension = Array.isArray(files)
-                ? 'cube'
-                : files.startsWith('data:application/exr')
-                    ? 'exr'
-                    : files.startsWith('data:application/hdr')
-                        ? 'hdr'
-                        : files.split('.').pop()?.split('?')?.shift()?.toLowerCase();
-            return isCubeMap
-                ? CubeTextureLoader
-                : extension === 'hdr'
-                    ? RGBELoader
-                    : extension === 'exr'
-                        ? EXRLoader
-                        : null;
-        }, () => {
-            const { files } = params();
-            return Array.isArray(files) ? [files] : files;
-        }, {
-            extensions: (loader) => {
-                const { path, extensions } = params();
-                loader.setPath(path);
-                if (extensions)
-                    extensions(loader);
-            },
-        });
-        const sRGBEncoding = 3001;
-        const LinearEncoding = 3000;
-        effect(() => {
-            const result = loaderResult();
-            if (!result)
-                return;
-            const { files, encoding } = params();
-            const texture = Array.isArray(files) ? result[0] : result;
-            texture.mapping = Array.isArray(files) ? CubeReflectionMapping : EquirectangularReflectionMapping;
-            if ('colorSpace' in texture) {
-                texture.colorSpace = encoding ?? Array.isArray(files) ? 'srgb' : 'srgb-linear';
-            }
-            else {
-                texture.encoding = encoding ?? Array.isArray(files) ? sRGBEncoding : LinearEncoding;
-            }
-            textureRef.nativeElement = texture;
-            safeDetectChanges(cdr);
-        });
-        return textureRef;
-    });
-}
-
-class NgtsEnvironmentCube {
-    set _background(background) {
-        this.inputs.set({ background });
-    }
-    constructor() {
-        this.environmentInput = inject(NgtsEnvironmentInput);
-        this.inputs = signalStore({ background: false });
-        this.store = injectNgtStore();
-        this.scene = this.store.select('scene');
-        this.background = this.inputs.select('background');
-        this.textureRef = injectNgtsEnvironment(this.environmentInput.params);
-        this.setEnvProps();
-    }
-    setEnvProps() {
-        effect((onCleanup) => {
-            const [defaultScene, scene, background, blur, texture] = [
-                this.scene(),
-                this.environmentInput.scene(),
-                this.background(),
-                this.environmentInput.blur(),
-                this.textureRef.nativeElement,
-            ];
-            if (!texture)
-                return;
-            const cleanUp = setEnvProps(background, scene, defaultScene, texture, blur);
-            onCleanup(cleanUp);
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentCube, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsEnvironmentCube, isStandalone: true, selector: "ngts-environment-cube", inputs: { _background: ["background", "_background"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentCube, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'ngts-environment-cube',
-                    standalone: true,
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { _background: [{
-                type: Input,
-                args: [{ alias: 'background' }]
-            }] } });
-
-class NgtsEnvironmentMap {
-    set _map(map) {
-        this.inputs.set({ map });
-    }
-    set _background(background) {
-        this.inputs.set({ background });
-    }
-    constructor() {
-        this.environmentInput = inject(NgtsEnvironmentInput);
-        this.store = injectNgtStore();
-        this.inputs = signalStore({ background: false });
-        this.scene = this.store.select('scene');
-        this.background = this.inputs.select('background');
-        this.map = this.inputs.select('map');
-        this.setEnvProps();
-    }
-    setEnvProps() {
-        effect((onCleanup) => {
-            const [defaultScene, scene, background, blur, texture] = [
-                this.scene(),
-                this.environmentInput.scene(),
-                this.background(),
-                this.environmentInput.blur(),
-                this.map(),
-            ];
-            if (!texture)
-                return;
-            const cleanUp = setEnvProps(background, scene, defaultScene, texture, blur);
-            onCleanup(cleanUp);
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentMap, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsEnvironmentMap, isStandalone: true, selector: "ngts-environment-map", inputs: { _map: ["map", "_map"], _background: ["background", "_background"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentMap, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'ngts-environment-map',
-                    standalone: true,
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { _map: [{
-                type: Input,
-                args: [{ alias: 'map' }]
-            }], _background: [{
-                type: Input,
-                args: [{ alias: 'background' }]
-            }] } });
-
-extend({ GroundProjectedEnv });
-class NgtsEnvironmentGround {
-    constructor() {
-        this.environmentInput = inject(NgtsEnvironmentInput);
-        this.defaultTexture = injectNgtsEnvironment(this.environmentInput.params);
-        this.texture = computed(() => {
-            const defaultTexture = this.defaultTexture.nativeElement;
-            return this.environmentInput.map() || defaultTexture;
-        });
-        this.groundArgs = computed(() => (this.texture() ? [this.texture()] : []));
-        this.height = computed(() => this.environmentInput.ground()?.height);
-        this.radius = computed(() => this.environmentInput.ground()?.radius);
-        this.scale = computed(() => this.environmentInput.ground()?.scale ?? 1000);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentGround, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsEnvironmentGround, isStandalone: true, selector: "ngts-environment-ground", ngImport: i0, template: `
-		<ngts-environment-map [map]="texture()" [background]="!!environmentInput.background()" />
-		<ngt-ground-projected-env *args="groundArgs()" [scale]="scale()" [height]="height()" [radius]="radius()" />
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["map", "background"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentGround, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-environment-ground',
-                    standalone: true,
-                    template: `
-		<ngts-environment-map [map]="texture()" [background]="!!environmentInput.background()" />
-		<ngt-ground-projected-env *args="groundArgs()" [scale]="scale()" [height]="height()" [radius]="radius()" />
-	`,
-                    imports: [NgtsEnvironmentMap, NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }] });
-
-extend({ CubeCamera });
-class NgtsEnvironmentPortal {
-    constructor() {
-        this.environmentInput = inject(NgtsEnvironmentInput);
-        this.store = injectNgtStore();
-        this.gl = this.store.select('gl');
-        this.scene = this.store.select('scene');
-        this.virtualSceneRef = injectNgtRef(prepare(new THREE.Scene()));
-        this.cubeCameraRef = injectNgtRef();
-        this.fbo = computed(() => {
-            const fbo = new THREE.WebGLCubeRenderTarget(this.environmentInput.resolution());
-            fbo.texture.type = THREE.HalfFloatType;
-            return fbo;
-        });
-        this.cameraArgs = computed(() => [this.environmentInput.near(), this.environmentInput.far(), this.fbo()]);
-        effect(() => {
-            this.environmentInput.inputs.patch({
-                near: 1,
-                far: 1000,
-                resolution: 256,
-                frames: 1,
-                background: false,
-                preset: undefined,
-            });
-        });
-        this.setEnvProps();
-        this.beforeRender();
-    }
-    setEnvProps() {
-        effect((onCleanup) => {
-            const [virtualScene, blur, frames, background, scene, fbo, defaultScene, gl, cubeCamera] = [
-                this.virtualSceneRef.nativeElement,
-                this.environmentInput.blur(),
-                this.environmentInput.frames(),
-                this.environmentInput.background(),
-                this.environmentInput.scene(),
-                this.fbo(),
-                this.scene(),
-                this.gl(),
-                this.cubeCameraRef.nativeElement,
-            ];
-            if (!cubeCamera || !virtualScene)
-                return;
-            if (frames === 1)
-                cubeCamera.update(gl, virtualScene);
-            const cleanUp = setEnvProps(background, scene, defaultScene, fbo.texture, blur);
-            onCleanup(cleanUp);
-        });
-    }
-    beforeRender() {
-        let count = 1;
-        injectBeforeRender(({ gl }) => {
-            const { frames } = this.environmentInput.inputs.get();
-            if (frames === Infinity || count < frames) {
-                const camera = this.cubeCameraRef.nativeElement;
-                const virtualScene = this.virtualSceneRef.nativeElement;
-                if (camera && virtualScene) {
-                    camera.update(gl, virtualScene);
-                    count++;
-                }
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsEnvironmentPortal, isStandalone: true, selector: "ngts-environment-portal", ngImport: i0, template: `
-		<ngt-portal [container]="virtualSceneRef">
-			<ng-template ngtPortalContent>
-				<ng-content />
-				<ngt-cube-camera *args="cameraArgs()" [ref]="cubeCameraRef" />
-				<ng-container *ngIf="environmentInput.files() || environmentInput.preset(); else environmentMap">
-					<ngts-environment-cube [background]="true" />
-				</ng-container>
-				<ng-template #environmentMap>
-					<ngts-environment-map *ngIf="environmentInput.map() as map" [background]="true" [map]="map" />
-				</ng-template>
-			</ng-template>
-		</ngt-portal>
-	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"], outputs: ["beforeRender"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[ngtPortalContent]" }, { kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["map", "background"] }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["background"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironmentPortal, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-environment-portal',
-                    standalone: true,
-                    template: `
-		<ngt-portal [container]="virtualSceneRef">
-			<ng-template ngtPortalContent>
-				<ng-content />
-				<ngt-cube-camera *args="cameraArgs()" [ref]="cubeCameraRef" />
-				<ng-container *ngIf="environmentInput.files() || environmentInput.preset(); else environmentMap">
-					<ngts-environment-cube [background]="true" />
-				</ng-container>
-				<ng-template #environmentMap>
-					<ngts-environment-map *ngIf="environmentInput.map() as map" [background]="true" [map]="map" />
-				</ng-template>
-			</ng-template>
-		</ngt-portal>
-	`,
-                    imports: [NgtPortal, NgtPortalContent, NgtsEnvironmentMap, NgtsEnvironmentCube, NgIf, NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; } });
-
-class NgtsEnvironment extends NgtsEnvironmentInput {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironment, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsEnvironment, isStandalone: true, selector: "ngts-environment", providers: [{ provide: NgtsEnvironmentInput, useExisting: NgtsEnvironment }], queries: [{ propertyName: "content", first: true, predicate: NgtsSobaContent, descendants: true, read: TemplateRef }], usesInheritance: true, ngImport: i0, template: `
-		<ngts-environment-ground *ngIf="ground(); else noGround" />
-		<ng-template #noGround>
-			<ngts-environment-map *ngIf="map() as map; else noMap" [map]="map" [background]="!!background()" />
-			<ng-template #noMap>
-				<ngts-environment-portal *ngIf="content; else noPortal">
-					<ng-container *ngTemplateOutlet="content" />
-				</ngts-environment-portal>
-				<ng-template #noPortal>
-					<ngts-environment-cube [background]="!!background()" />
-				</ng-template>
-			</ng-template>
-		</ng-template>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["map", "background"] }, { kind: "component", type: NgtsEnvironmentGround, selector: "ngts-environment-ground" }, { kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["background"] }, { kind: "component", type: NgtsEnvironmentPortal, selector: "ngts-environment-portal" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsEnvironment, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-environment',
-                    standalone: true,
-                    template: `
-		<ngts-environment-ground *ngIf="ground(); else noGround" />
-		<ng-template #noGround>
-			<ngts-environment-map *ngIf="map() as map; else noMap" [map]="map" [background]="!!background()" />
-			<ng-template #noMap>
-				<ngts-environment-portal *ngIf="content; else noPortal">
-					<ng-container *ngTemplateOutlet="content" />
-				</ngts-environment-portal>
-				<ng-template #noPortal>
-					<ngts-environment-cube [background]="!!background()" />
-				</ng-template>
-			</ng-template>
-		</ng-template>
-	`,
-                    imports: [
-                        NgtsEnvironmentMap,
-                        NgtsEnvironmentGround,
-                        NgtsEnvironmentCube,
-                        NgtsEnvironmentPortal,
-                        NgIf,
-                        NgTemplateOutlet,
-                    ],
-                    providers: [{ provide: NgtsEnvironmentInput, useExisting: NgtsEnvironment }],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], propDecorators: { content: [{
-                type: ContentChild,
-                args: [NgtsSobaContent, { read: TemplateRef }]
-            }] } });
-
-extend({ Group });
-class NgtsFloat {
-    set _enabled(enabled) {
-        this.inputs.set({ enabled });
-    }
-    set _speed(speed) {
-        this.inputs.set({ speed });
-    }
-    set _rotationIntensity(rotationIntensity) {
-        this.inputs.set({ rotationIntensity });
-    }
-    set _floatIntensity(floatIntensity) {
-        this.inputs.set({ floatIntensity });
-    }
-    set _floatingRange(floatingRange) {
-        this.inputs.set({ floatingRange });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            enabled: true,
-            speed: 1,
-            rotationIntensity: 1,
-            floatIntensity: 1,
-            floatingRange: [-0.1, 0.1],
-        });
-        this.floatRef = injectNgtRef();
-        this.beforeRender();
-    }
-    beforeRender() {
-        const offset = Math.random() * 10000;
-        injectBeforeRender(({ clock }) => {
-            const float = this.floatRef.nativeElement;
-            if (!float)
-                return;
-            const { enabled, speed, rotationIntensity, floatingRange, floatIntensity } = this.inputs.get();
-            if (!enabled || speed === 0)
-                return;
-            const t = offset + clock.getElapsedTime();
-            float.rotation.x = (Math.cos((t / 4) * speed) / 8) * rotationIntensity;
-            float.rotation.y = (Math.sin((t / 4) * speed) / 8) * rotationIntensity;
-            float.rotation.z = (Math.sin((t / 4) * speed) / 20) * rotationIntensity;
-            let yPosition = Math.sin((t / 4) * speed) / 10;
-            yPosition = THREE.MathUtils.mapLinear(yPosition, -0.1, 0.1, floatingRange?.[0] ?? -0.1, floatingRange?.[1] ?? 0.1);
-            float.position.y = yPosition * floatIntensity;
-            float.updateMatrix();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsFloat, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsFloat, isStandalone: true, selector: "ngts-float", inputs: { floatRef: "floatRef", _enabled: ["enabled", "_enabled"], _speed: ["speed", "_speed"], _rotationIntensity: ["rotationIntensity", "_rotationIntensity"], _floatIntensity: ["floatIntensity", "_floatIntensity"], _floatingRange: ["floatingRange", "_floatingRange"] }, ngImport: i0, template: `
-		<ngt-group ngtCompound>
-			<ngt-group [ref]="floatRef" [matrixAutoUpdate]="false">
-				<ng-content />
-			</ngt-group>
-		</ngt-group>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsFloat, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-float',
-                    standalone: true,
-                    template: `
-		<ngt-group ngtCompound>
-			<ngt-group [ref]="floatRef" [matrixAutoUpdate]="false">
-				<ng-content />
-			</ngt-group>
-		</ngt-group>
-	`,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { floatRef: [{
-                type: Input
-            }], _enabled: [{
-                type: Input,
-                args: [{ alias: 'enabled' }]
-            }], _speed: [{
-                type: Input,
-                args: [{ alias: 'speed' }]
-            }], _rotationIntensity: [{
-                type: Input,
-                args: [{ alias: 'rotationIntensity' }]
-            }], _floatIntensity: [{
-                type: Input,
-                args: [{ alias: 'floatIntensity' }]
-            }], _floatingRange: [{
-                type: Input,
-                args: [{ alias: 'floatingRange' }]
-            }] } });
-
-function getFormatString(format) {
-    switch (format) {
-        case 64:
-            return '-64px';
-        case 128:
-            return '-128px';
-        case 256:
-            return '-256px';
-        case 512:
-            return '-512px';
-        default:
-            return '';
-    }
-}
-const LIST_URL$1 = 'https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master/matcaps.json';
-const MATCAP_ROOT = 'https://rawcdn.githack.com/emmelleppi/matcaps/9b36ccaaf0a24881a39062d05566c9e92be4aa0d';
-const defaultState$1 = {
-    id: 0,
-    format: 1024,
-};
-function injectNgtsMatcapTexture(matcapTextureState, { injector } = {}) {
-    injector = assertInjectionContext(injectNgtsMatcapTexture, injector);
-    return runInInjectionContext(injector, () => {
-        const state = computed(() => ({ ...defaultState$1, ...matcapTextureState() }));
-        const matcapList = signal({});
-        const DEFAULT_MATCAP = () => matcapList()[0];
-        const numTot = () => Object.keys(matcapList()).length;
-        effect(() => {
-            if (!untracked(numTot)) {
-                fetch(LIST_URL$1)
-                    .then((res) => res.json())
-                    .then((data) => {
-                    matcapList.set(data);
-                });
-            }
-        });
-        const fileHash = () => {
-            const id = state().id;
-            if (typeof id === 'string') {
-                return id;
-            }
-            if (typeof id === 'number' && matcapList()[id]) {
-                return matcapList()[id];
-            }
-            return null;
-        };
-        const fileName = () => `${fileHash() || DEFAULT_MATCAP()}${getFormatString(state().format)}.png`;
-        const url = () => `${MATCAP_ROOT}/${state().format}/${fileName()}`;
-        let texture;
-        const matcapTexture = computed(() => {
-            if (url().includes('undefined'))
-                return null;
-            if (!texture) {
-                texture = injectNgtsTextureLoader(url, { onLoad: state().onLoad, injector });
-            }
-            return texture();
-        });
-        return { texture: matcapTexture, numTot, url };
-    });
-}
-
-const NORMAL_ROOT = 'https://rawcdn.githack.com/pmndrs/drei-assets/7a3104997e1576f83472829815b00880d88b32fb';
-const LIST_URL = 'https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master/normals/normals.json';
-const defaultState = {
-    id: 0,
-    repeat: [1, 1],
-    anisotropy: 1,
-    offset: [0, 0],
-};
-function injectNgtsNormalTexture(normalTextureState, { injector } = {}) {
-    injector = assertInjectionContext(injectNgtsNormalTexture, injector);
-    return runInInjectionContext(injector, () => {
-        const state = computed(() => ({ ...defaultState, ...normalTextureState() }));
-        const normalsList = signal({});
-        const DEFAULT_NORMAL = () => normalsList()[0];
-        const numTot = () => Object.keys(normalsList()).length;
-        effect(() => {
-            if (!untracked(numTot)) {
-                fetch(LIST_URL)
-                    .then((res) => res.json())
-                    .then((data) => {
-                    normalsList.set(data);
-                });
-            }
-        });
-        const imageName = () => normalsList()[state().id] || DEFAULT_NORMAL();
-        const url = () => `${NORMAL_ROOT}/normals/${imageName()}`;
-        let texture;
-        const normalTexture = computed(() => {
-            if (url().includes('undefined'))
-                return null;
-            if (!texture) {
-                texture = injectNgtsTextureLoader(url, { onLoad: state().onLoad, injector });
-            }
-            return texture();
-        });
-        effect(() => {
-            const _texture = normalTexture();
-            if (!_texture)
-                return;
-            const { repeat, offset, anisotropy } = state();
-            _texture.wrapS = _texture.wrapT = THREE.RepeatWrapping;
-            _texture.repeat = new THREE.Vector2(repeat[0], repeat[1]);
-            _texture.offset = new THREE.Vector2(offset[0], offset[1]);
-            _texture.anisotropy = anisotropy;
-        });
-        return { texture: normalTexture, numTot, url };
-    });
-}
-
-function calcPosFromAngles(inclination, azimuth, vector = new THREE.Vector3()) {
-    const theta = Math.PI * (inclination - 0.5);
-    const phi = 2 * Math.PI * (azimuth - 0.5);
-    vector.x = Math.cos(phi);
-    vector.y = Math.sin(theta);
-    vector.z = Math.sin(phi);
-    return vector;
-}
-class NgtsSky {
-    constructor() {
-        this.inputs = signalStore({
-            inclination: 0.6,
-            azimuth: 0.1,
-            distance: 1000,
-            mieCoefficient: 0.005,
-            mieDirectionalG: 0.8,
-            rayleigh: 0.5,
-            turbidity: 10,
-        });
-        this.skyRef = injectNgtRef();
-        this.inclination = this.inputs.select('inclination');
-        this.azimuth = this.inputs.select('azimuth');
-        this.sunPos = this.inputs.select('sunPosition');
-        this.distance = this.inputs.select('distance');
-        this.sunPosition = computed(() => this.sunPos() || calcPosFromAngles(this.inclination(), this.azimuth()));
-        this.scale = computed(() => new THREE.Vector3().setScalar(this.distance()));
-        this.mieCoefficient = this.inputs.select('mieCoefficient');
-        this.mieDirectionalG = this.inputs.select('mieDirectionalG');
-        this.rayleigh = this.inputs.select('rayleigh');
-        this.turbidity = this.inputs.select('turbidity');
-        this.sky = new Sky();
-    }
-    set _distance(distance) {
-        this.inputs.set({ distance });
-    }
-    set _sunPosition(sunPosition) {
-        this.inputs.set({ sunPosition });
-    }
-    set _inclination(inclination) {
-        this.inputs.set({ inclination });
-    }
-    set _azimuth(azimuth) {
-        this.inputs.set({ azimuth });
-    }
-    set _mieCoefficient(mieCoefficient) {
-        this.inputs.set({ mieCoefficient });
-    }
-    set _mieDirectionalG(mieDirectionalG) {
-        this.inputs.set({ mieDirectionalG });
-    }
-    set _rayleigh(rayleigh) {
-        this.inputs.set({ rayleigh });
-    }
-    set _turbidity(turbidity) {
-        this.inputs.set({ turbidity });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSky, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSky, isStandalone: true, selector: "ngts-sky", inputs: { skyRef: "skyRef", _distance: ["distance", "_distance"], _sunPosition: ["sunPosition", "_sunPosition"], _inclination: ["inclination", "_inclination"], _azimuth: ["azimuth", "_azimuth"], _mieCoefficient: ["mieCoefficient", "_mieCoefficient"], _mieDirectionalG: ["mieDirectionalG", "_mieDirectionalG"], _rayleigh: ["rayleigh", "_rayleigh"], _turbidity: ["turbidity", "_turbidity"] }, ngImport: i0, template: `
-		<ngt-primitive *args="[sky]" [ref]="skyRef" [scale]="scale()" ngtCompound>
-			<ngt-value [rawValue]="mieCoefficient()" attach="material.uniforms.mieCoefficient.value" />
-			<ngt-value [rawValue]="mieDirectionalG()" attach="material.uniforms.mieDirectionalG.value" />
-			<ngt-value [rawValue]="rayleigh()" attach="material.uniforms.rayleigh.value" />
-			<ngt-value [rawValue]="sunPosition()" attach="material.uniforms.sunPosition.value" />
-			<ngt-value [rawValue]="turbidity()" attach="material.uniforms.turbidity.value" />
-			<ng-content />
-		</ngt-primitive>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSky, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-sky',
-                    standalone: true,
-                    template: `
-		<ngt-primitive *args="[sky]" [ref]="skyRef" [scale]="scale()" ngtCompound>
-			<ngt-value [rawValue]="mieCoefficient()" attach="material.uniforms.mieCoefficient.value" />
-			<ngt-value [rawValue]="mieDirectionalG()" attach="material.uniforms.mieDirectionalG.value" />
-			<ngt-value [rawValue]="rayleigh()" attach="material.uniforms.rayleigh.value" />
-			<ngt-value [rawValue]="sunPosition()" attach="material.uniforms.sunPosition.value" />
-			<ngt-value [rawValue]="turbidity()" attach="material.uniforms.turbidity.value" />
-			<ng-content />
-		</ngt-primitive>
-	`,
-                    imports: [NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], propDecorators: { skyRef: [{
-                type: Input
-            }], _distance: [{
-                type: Input,
-                args: [{ alias: 'distance' }]
-            }], _sunPosition: [{
-                type: Input,
-                args: [{ alias: 'sunPosition' }]
-            }], _inclination: [{
-                type: Input,
-                args: [{ alias: 'inclination' }]
-            }], _azimuth: [{
-                type: Input,
-                args: [{ alias: 'azimuth' }]
-            }], _mieCoefficient: [{
-                type: Input,
-                args: [{ alias: 'mieCoefficient' }]
-            }], _mieDirectionalG: [{
-                type: Input,
-                args: [{ alias: 'mieDirectionalG' }]
-            }], _rayleigh: [{
-                type: Input,
-                args: [{ alias: 'rayleigh' }]
-            }], _turbidity: [{
-                type: Input,
-                args: [{ alias: 'turbidity' }]
-            }] } });
-
-extend({ SparklesMaterial, Points, BufferGeometry, BufferAttribute });
-const isFloat32Array = (def) => def && def.constructor === Float32Array;
-const expandColor = (v) => [v.r, v.g, v.b];
-const isVector = (v) => v instanceof THREE.Vector2 || v instanceof THREE.Vector3 || v instanceof THREE.Vector4;
-const normalizeVector = (v) => {
-    if (Array.isArray(v))
-        return v;
-    else if (isVector(v))
-        return v.toArray();
-    return [v, v, v];
-};
-function usePropAsIsOrAsAttribute(count, prop, setDefault) {
-    if (prop !== undefined) {
-        if (isFloat32Array(prop)) {
-            return prop;
-        }
-        if (prop instanceof THREE.Color) {
-            const a = Array.from({ length: count * 3 }, () => expandColor(prop)).flat();
-            return Float32Array.from(a);
-        }
-        if (isVector(prop) || Array.isArray(prop)) {
-            const a = Array.from({ length: count * 3 }, () => normalizeVector(prop)).flat();
-            return Float32Array.from(a);
-        }
-        return Float32Array.from({ length: count }, () => prop);
-    }
-    return Float32Array.from({ length: count }, setDefault);
-}
-class NgtsSparkles {
-    /** Number of particles (default: 100) */
-    set _count(count) {
-        this.inputs.set({ count });
-    }
-    /** Speed of particles (default: 1) */
-    set _speed(speed) {
-        this.inputs.set({ speed });
-    }
-    /** Opacity of particles (default: 1) */
-    set _opacity(opacity) {
-        this.inputs.set({ opacity });
-    }
-    /** Color of particles (default: 100) */
-    set _color(color) {
-        this.inputs.set({ color });
-    }
-    /** Size of particles (default: randomized between 0 and 1) */
-    set _size(size) {
-        this.inputs.set({ size });
-    }
-    /** The space the particles occupy (default: 1) */
-    set _scale(scale) {
-        this.inputs.set({ scale });
-    }
-    /** Movement factor (default: 1) */
-    set _noise(noise) {
-        this.inputs.set({ noise });
-    }
-    constructor() {
-        this.inputs = signalStore({
-            noise: 1,
-            count: 100,
-            speed: 1,
-            opacity: 1,
-            scale: 1,
-        });
-        this.sparklesRef = injectNgtRef();
-        this.store = injectNgtStore();
-        this.dpr = this.store.select('viewport', 'dpr');
-        this.scale = this.inputs.select('scale');
-        this.count = this.inputs.select('count');
-        this.color = this.inputs.select('color');
-        this.positions = computed(() => Float32Array.from(Array.from({ length: this.count() }, () => normalizeVector(this.scale()).map(THREE.MathUtils.randFloatSpread)).flat()));
-        this.sizes = this.getComputed('size', this.count, Math.random);
-        this.opacities = this.getComputed('opacity', this.count);
-        this.speeds = this.getComputed('speed', this.count);
-        this.noises = this.getComputed('noise', () => this.count() * 3);
-        this.colors = this.getComputed(computed(() => {
-            const color = this.color();
-            return !isFloat32Array(color) ? new THREE.Color(color) : color;
-        }), () => (this.color() === undefined ? this.count() * 3 : this.count()), () => 1);
-        this.key = computed(() => `particle-${this.count()}-${JSON.stringify(this.scale())}`);
-        this.beforeRender();
-    }
-    beforeRender() {
-        injectBeforeRender(({ clock }) => {
-            const sparkles = this.sparklesRef.nativeElement;
-            if (!sparkles || !sparkles.material)
-                return;
-            sparkles.material.time = clock.elapsedTime;
-        });
-    }
-    getComputed(nameOrComputed, count, setDefault) {
-        const value = typeof nameOrComputed !== 'string' && isSignal(nameOrComputed)
-            ? nameOrComputed
-            : this.inputs.select(nameOrComputed);
-        return computed(() => usePropAsIsOrAsAttribute(count(), value(), setDefault));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSparkles, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSparkles, isStandalone: true, selector: "ngts-sparkles", inputs: { sparklesRef: "sparklesRef", _count: ["count", "_count"], _speed: ["speed", "_speed"], _opacity: ["opacity", "_opacity"], _color: ["color", "_color"], _size: ["size", "_size"], _scale: ["scale", "_scale"], _noise: ["noise", "_noise"] }, ngImport: i0, template: `
-		<ngt-points *key="key()" ngtCompound [ref]="sparklesRef">
-			<ngt-buffer-geometry>
-				<ngt-buffer-attribute attach="attributes.position" *args="[positions(), 3]" />
-				<ngt-buffer-attribute attach="attributes.size" *args="[sizes(), 1]" />
-				<ngt-buffer-attribute attach="attributes.opacity" *args="[opacities(), 1]" />
-				<ngt-buffer-attribute attach="attributes.speed" *args="[speeds(), 1]" />
-				<ngt-buffer-attribute attach="attributes.color" *args="[colors(), 3]" />
-				<ngt-buffer-attribute attach="attributes.noise" *args="[noises(), 3]" />
-			</ngt-buffer-geometry>
-			<ngt-sparkles-material [transparent]="true" [depthWrite]="false" [pixelRatio]="dpr()" />
-		</ngt-points>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "directive", type: NgtKey, selector: "ng-template[key]", inputs: ["key"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSparkles, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-sparkles',
-                    standalone: true,
-                    template: `
-		<ngt-points *key="key()" ngtCompound [ref]="sparklesRef">
-			<ngt-buffer-geometry>
-				<ngt-buffer-attribute attach="attributes.position" *args="[positions(), 3]" />
-				<ngt-buffer-attribute attach="attributes.size" *args="[sizes(), 1]" />
-				<ngt-buffer-attribute attach="attributes.opacity" *args="[opacities(), 1]" />
-				<ngt-buffer-attribute attach="attributes.speed" *args="[speeds(), 1]" />
-				<ngt-buffer-attribute attach="attributes.color" *args="[colors(), 3]" />
-				<ngt-buffer-attribute attach="attributes.noise" *args="[noises(), 3]" />
-			</ngt-buffer-geometry>
-			<ngt-sparkles-material [transparent]="true" [depthWrite]="false" [pixelRatio]="dpr()" />
-		</ngt-points>
-	`,
-                    imports: [NgtArgs, NgtKey],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { sparklesRef: [{
-                type: Input
-            }], _count: [{
-                type: Input,
-                args: [{ alias: 'count' }]
-            }], _speed: [{
-                type: Input,
-                args: [{ alias: 'speed' }]
-            }], _opacity: [{
-                type: Input,
-                args: [{ alias: 'opacity' }]
-            }], _color: [{
-                type: Input,
-                args: [{ alias: 'color' }]
-            }], _size: [{
-                type: Input,
-                args: [{ alias: 'size' }]
-            }], _scale: [{
-                type: Input,
-                args: [{ alias: 'scale' }]
-            }], _noise: [{
-                type: Input,
-                args: [{ alias: 'noise' }]
-            }] } });
-
-class NgtsSpotLightShadowMeshInput {
-    constructor() {
-        this.inputs = signalStore({});
-        this.distance = this.inputs.select('distance');
-        this.alphaTest = this.inputs.select('alphaTest');
-        this.scale = this.inputs.select('scale');
-        this.map = this.inputs.select('map');
-        this.shader = this.inputs.select('shader');
-        this.width = this.inputs.select('width');
-        this.height = this.inputs.select('height');
-    }
-    set _distance(distance) {
-        this.inputs.set({ distance });
-    }
-    set _alphaTest(alphaTest) {
-        this.inputs.set({ alphaTest });
-    }
-    set _scale(scale) {
-        this.inputs.set({ scale });
-    }
-    set _map(map) {
-        this.inputs.set({ map });
-    }
-    set _shader(shader) {
-        this.inputs.set({ shader });
-    }
-    set _width(width) {
-        this.inputs.set({ width });
-    }
-    set _height(height) {
-        this.inputs.set({ height });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadowMeshInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSpotLightShadowMeshInput, inputs: { _distance: ["distance", "_distance"], _alphaTest: ["alphaTest", "_alphaTest"], _scale: ["scale", "_scale"], _map: ["map", "_map"], _shader: ["shader", "_shader"], _width: ["width", "_width"], _height: ["height", "_height"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadowMeshInput, decorators: [{
-            type: Directive
-        }], propDecorators: { _distance: [{
-                type: Input,
-                args: [{ alias: 'distance' }]
-            }], _alphaTest: [{
-                type: Input,
-                args: [{ alias: 'alphaTest' }]
-            }], _scale: [{
-                type: Input,
-                args: [{ alias: 'scale' }]
-            }], _map: [{
-                type: Input,
-                args: [{ alias: 'map' }]
-            }], _shader: [{
-                type: Input,
-                args: [{ alias: 'shader' }]
-            }], _width: [{
-                type: Input,
-                args: [{ alias: 'width' }]
-            }], _height: [{
-                type: Input,
-                args: [{ alias: 'height' }]
-            }] } });
-
-class NgtsSpotLightInput {
-    constructor() {
-        this.inputs = signalStore({});
-        this.debug = this.inputs.select('debug');
-        this.color = this.inputs.select('color');
-        this.opacity = this.inputs.select('opacity');
-        this.radiusBottom = this.inputs.select('radiusBottom');
-        this.radiusTop = this.inputs.select('radiusTop');
-        this.anglePower = this.inputs.select('anglePower');
-        this.attenuation = this.inputs.select('attenuation');
-        this.distance = this.inputs.select('distance');
-        this.angle = this.inputs.select('angle');
-        this.depthBuffer = this.inputs.select('depthBuffer');
-    }
-    set _depthBuffer(depthBuffer) {
-        this.inputs.set({ depthBuffer });
-    }
-    set _angle(angle) {
-        this.inputs.set({ angle });
-    }
-    set _distance(distance) {
-        this.inputs.set({ distance });
-    }
-    set _attenuation(attenuation) {
-        this.inputs.set({ attenuation });
-    }
-    set _anglePower(anglePower) {
-        this.inputs.set({ anglePower });
-    }
-    set _radiusTop(radiusTop) {
-        this.inputs.set({ radiusTop });
-    }
-    set _radiusBottom(radiusBottom) {
-        this.inputs.set({ radiusBottom });
-    }
-    set _opacity(opacity) {
-        this.inputs.set({ opacity });
-    }
-    set _color(color) {
-        this.inputs.set({ color });
-    }
-    set _debug(debug) {
-        this.inputs.set({ debug });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSpotLightInput, inputs: { _depthBuffer: ["depthBuffer", "_depthBuffer"], _angle: ["angle", "_angle"], _distance: ["distance", "_distance"], _attenuation: ["attenuation", "_attenuation"], _anglePower: ["anglePower", "_anglePower"], _radiusTop: ["radiusTop", "_radiusTop"], _radiusBottom: ["radiusBottom", "_radiusBottom"], _opacity: ["opacity", "_opacity"], _color: ["color", "_color"], _debug: ["debug", "_debug"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightInput, decorators: [{
-            type: Directive
-        }], propDecorators: { _depthBuffer: [{
-                type: Input,
-                args: [{ alias: 'depthBuffer' }]
-            }], _angle: [{
-                type: Input,
-                args: [{ alias: 'angle' }]
-            }], _distance: [{
-                type: Input,
-                args: [{ alias: 'distance' }]
-            }], _attenuation: [{
-                type: Input,
-                args: [{ alias: 'attenuation' }]
-            }], _anglePower: [{
-                type: Input,
-                args: [{ alias: 'anglePower' }]
-            }], _radiusTop: [{
-                type: Input,
-                args: [{ alias: 'radiusTop' }]
-            }], _radiusBottom: [{
-                type: Input,
-                args: [{ alias: 'radiusBottom' }]
-            }], _opacity: [{
-                type: Input,
-                args: [{ alias: 'opacity' }]
-            }], _color: [{
-                type: Input,
-                args: [{ alias: 'color' }]
-            }], _debug: [{
-                type: Input,
-                args: [{ alias: 'debug' }]
-            }] } });
-
-extend({ Mesh });
-class NgtsVolumetricMesh {
-    constructor() {
-        this.spotLightInput = inject(NgtsSpotLightInput);
-        this.mesh = injectNgtRef();
-        this.material = new SpotLightMaterial();
-        this.nullRaycast = () => null;
-        this.vec = new THREE.Vector3();
-        this.store = injectNgtStore();
-        this.size = this.store.select('size');
-        this.dpr = this.store.select('viewport', 'dpr');
-        this.radiusTop = computed(() => {
-            const radiusTop = this.spotLightInput.radiusTop();
-            return radiusTop === undefined ? 0.1 : radiusTop;
-        });
-        this.radiusBottom = computed(() => {
-            const [angle, radiusBottom] = [this.spotLightInput.angle(), this.spotLightInput.radiusBottom()];
-            return radiusBottom === undefined ? angle * 7 : radiusBottom;
-        });
-        this.near = this.store.select('camera', 'near');
-        this.far = this.store.select('camera', 'far');
-        this.resolution = computed(() => this.spotLightInput.depthBuffer() ? [this.size().width * this.dpr(), this.size().height * this.dpr()] : [0, 0]);
-        this.geometry = computed(() => {
-            const [radiusTop, radiusBottom, distance] = [
-                this.radiusTop(),
-                this.radiusBottom(),
-                this.spotLightInput.distance(),
-            ];
-            const geometry = new THREE.CylinderGeometry(radiusTop, radiusBottom, distance, 128, 64, true);
-            geometry.applyMatrix4(new THREE.Matrix4().makeTranslation(0, -distance / 2, 0));
-            geometry.applyMatrix4(new THREE.Matrix4().makeRotationX(-Math.PI / 2));
-            return geometry;
-        });
-        this.beforeRender();
-        effect(() => {
-            this.spotLightInput.inputs.patch({
-                opacity: 1,
-                color: 'white',
-                distance: 5,
-                angle: 0.15,
-                attenuation: 5,
-                anglePower: 5,
-            });
-        });
-    }
-    beforeRender() {
-        injectBeforeRender(() => {
-            this.material.uniforms['spotPosition'].value.copy(this.mesh.nativeElement.getWorldPosition(this.vec));
-            this.mesh.nativeElement.lookAt(this.mesh.nativeElement.parent.target.getWorldPosition(this.vec));
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsVolumetricMesh, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsVolumetricMesh, isStandalone: true, selector: "ngts-volumetric-mesh", ngImport: i0, template: `
-		<ngt-mesh [ref]="mesh" [geometry]="geometry()" [raycast]="nullRaycast">
-			<ngt-primitive *args="[material]" attach="material">
-				<ngt-value [rawValue]="spotLightInput.opacity()" attach="uniforms.opacity.value" />
-				<ngt-value [rawValue]="spotLightInput.color()" attach="uniforms.lightColor.value" />
-				<ngt-value [rawValue]="spotLightInput.attenuation()" attach="uniforms.attenuation.value" />
-				<ngt-value [rawValue]="spotLightInput.anglePower()" attach="uniforms.anglePower.value" />
-				<ngt-value [rawvalue]="spotLightInput.depthBuffer()" attach="uniforms.depth.value" />
-				<ngt-value [rawvalue]="near()" attach="uniforms.cameraNear.value" />
-				<ngt-value [rawvalue]="far()" attach="uniforms.cameraFar.value" />
-				<ngt-value [rawvalue]="resolution()" attach="uniforms.resolution.value" />
-			</ngt-primitive>
-		</ngt-mesh>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsVolumetricMesh, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-volumetric-mesh',
-                    standalone: true,
-                    template: `
-		<ngt-mesh [ref]="mesh" [geometry]="geometry()" [raycast]="nullRaycast">
-			<ngt-primitive *args="[material]" attach="material">
-				<ngt-value [rawValue]="spotLightInput.opacity()" attach="uniforms.opacity.value" />
-				<ngt-value [rawValue]="spotLightInput.color()" attach="uniforms.lightColor.value" />
-				<ngt-value [rawValue]="spotLightInput.attenuation()" attach="uniforms.attenuation.value" />
-				<ngt-value [rawValue]="spotLightInput.anglePower()" attach="uniforms.anglePower.value" />
-				<ngt-value [rawvalue]="spotLightInput.depthBuffer()" attach="uniforms.depth.value" />
-				<ngt-value [rawvalue]="near()" attach="uniforms.cameraNear.value" />
-				<ngt-value [rawvalue]="far()" attach="uniforms.cameraFar.value" />
-				<ngt-value [rawvalue]="resolution()" attach="uniforms.resolution.value" />
-			</ngt-primitive>
-		</ngt-mesh>
-	`,
-                    imports: [NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; } });
-
-extend({ SpotLight, SpotLightHelper, Group });
-const [injectNgtsSpotLightApi, provideNgtsSpotLightApi] = createInjectionToken((spotLight) => ({ spotLight: spotLight.spotLightRef, debug: spotLight.debug }), { isRoot: false, deps: [forwardRef(() => NgtsSpotLight)] });
-class NgtsSpotLight extends NgtsSpotLightInput {
-    set _volumetric(volumetric) {
-        this.volumetric.set(volumetric);
-    }
-    constructor() {
-        super();
-        this.spotLightRef = injectNgtRef();
-        this.volumetric = signal(true);
-        this.inputs.set({
-            opacity: 1,
-            color: 'white',
-            distance: 5,
-            angle: 0.15,
-            attenuation: 5,
-            anglePower: 5,
-            debug: false,
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLight, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSpotLight, isStandalone: true, selector: "ngts-spot-light", inputs: { spotLightRef: "spotLightRef", _volumetric: ["volumetric", "_volumetric"] }, providers: [provideNgtsSpotLightApi(), { provide: NgtsSpotLightInput, useExisting: NgtsSpotLight }], usesInheritance: true, ngImport: i0, template: `
-		<ngt-group>
-			<ng-container *ngIf="debug() && spotLightRef.nativeElement">
-				<ngt-spot-light-helper *args="[spotLightRef.nativeElement]" />
-			</ng-container>
-			<ngt-spot-light
-				[ref]="spotLightRef"
-				[color]="color()"
-				[distance]="distance()"
-				[angle]="angle()"
-				[castShadow]="true"
-				ngtCompound
-			>
-				<ngts-volumetric-mesh *ngIf="volumetric()" />
-			</ngt-spot-light>
-			<ng-content />
-		</ngt-group>
-	`, isInline: true, dependencies: [{ kind: "component", type: NgtsVolumetricMesh, selector: "ngts-volumetric-mesh" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLight, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-spot-light',
-                    standalone: true,
-                    template: `
-		<ngt-group>
-			<ng-container *ngIf="debug() && spotLightRef.nativeElement">
-				<ngt-spot-light-helper *args="[spotLightRef.nativeElement]" />
-			</ng-container>
-			<ngt-spot-light
-				[ref]="spotLightRef"
-				[color]="color()"
-				[distance]="distance()"
-				[angle]="angle()"
-				[castShadow]="true"
-				ngtCompound
-			>
-				<ngts-volumetric-mesh *ngIf="volumetric()" />
-			</ngt-spot-light>
-			<ng-content />
-		</ngt-group>
-	`,
-                    imports: [NgtsVolumetricMesh, NgIf, NgtArgs],
-                    providers: [provideNgtsSpotLightApi(), { provide: NgtsSpotLightInput, useExisting: NgtsSpotLight }],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; }, propDecorators: { spotLightRef: [{
-                type: Input
-            }], _volumetric: [{
-                type: Input,
-                args: [{ alias: 'volumetric' }]
-            }] } });
-
-const isSpotLight = (child) => {
-    return child?.isSpotLight;
-};
-function injectShadowMeshCommon(spotLightRef, meshRef, width, height, distance, injector) {
-    injector = assertInjectionContext(injectShadowMeshCommon, injector);
-    runInInjectionContext(injector, () => {
-        const pos = new THREE.Vector3();
-        const dir = new THREE.Vector3();
-        effect(() => {
-            const spotLight = spotLightRef.nativeElement;
-            if (!spotLight)
-                return;
-            if (isSpotLight(spotLight)) {
-                spotLight.shadow.mapSize.set(width(), height());
-                if (spotLight.shadow.map) {
-                    spotLight.shadow.map.setSize(width(), height());
-                }
-                spotLight.shadow.needsUpdate = true;
-            }
-            else {
-                throw new Error('<ngts-spot-light-shadow> must be a child of a <ngts-spot-light>');
-            }
-        });
-        injectBeforeRender(() => {
-            const spotLight = spotLightRef.nativeElement;
-            const mesh = meshRef.nativeElement;
-            if (!spotLight)
-                return;
-            const A = spotLight.position;
-            const B = spotLight.target.position;
-            dir.copy(B).sub(A);
-            const len = dir.length();
-            dir.normalize().multiplyScalar(len * distance());
-            pos.copy(A).add(dir);
-            if (mesh) {
-                mesh.position.copy(pos);
-                mesh.lookAt(spotLight.target.position);
-            }
-        });
-    });
-}
-extend({ Mesh, PlaneGeometry, MeshBasicMaterial });
-class NgtsSpotLightShadowMeshNoShader {
-    constructor() {
-        this.shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);
-        this.meshRef = injectNgtRef();
-        this.DoubleSide = THREE.DoubleSide;
-        this.spotLightApi = injectNgtsSpotLightApi();
-        this.debug = this.spotLightApi.debug;
-        effect(() => {
-            this.shadowMeshInput.inputs.patch({ distance: 0.4, alphaTest: 0.5, width: 512, height: 512, scale: 1 });
-        });
-        effect(() => {
-            const map = this.shadowMeshInput.map();
-            if (map) {
-                map.wrapS = map.wrapT = THREE.RepeatWrapping;
-                checkUpdate(map);
-            }
-        });
-        injectShadowMeshCommon(this.spotLightApi.spotLight, this.meshRef, this.shadowMeshInput.width, this.shadowMeshInput.height, this.shadowMeshInput.distance);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadowMeshNoShader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSpotLightShadowMeshNoShader, isStandalone: true, selector: "ngts-spot-light-shadow-mesh-no-shader", ngImport: i0, template: `
-		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
-			<ngt-plane-geometry />
-			<ngt-mesh-basic-material
-				[transparent]="true"
-				[side]="DoubleSide"
-				[alphaTest]="shadowMeshInput.alphaTest()"
-				[alphaMap]="shadowMeshInput.map()"
-				[opacity]="debug() ? 1 : 0"
-			>
-				<ng-content />
-			</ngt-mesh-basic-material>
-		</ngt-mesh>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadowMeshNoShader, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-spot-light-shadow-mesh-no-shader',
-                    standalone: true,
-                    template: `
-		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
-			<ngt-plane-geometry />
-			<ngt-mesh-basic-material
-				[transparent]="true"
-				[side]="DoubleSide"
-				[alphaTest]="shadowMeshInput.alphaTest()"
-				[alphaMap]="shadowMeshInput.map()"
-				[opacity]="debug() ? 1 : 0"
-			>
-				<ng-content />
-			</ngt-mesh-basic-material>
-		</ngt-mesh>
-	`,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; } });
-class NgtsSpotLightShadowMeshShader {
-    constructor() {
-        this.shadowMeshInput = inject(NgtsSpotLightShadowMeshInput);
-        this.meshRef = injectNgtRef();
-        this.DoubleSide = THREE.DoubleSide;
-        this.RepeatWrapping = THREE.RepeatWrapping;
-        this.spotLightApi = injectNgtsSpotLightApi();
-        this.debug = this.spotLightApi.debug;
-        this.renderTarget = computed(() => {
-            const [width, height] = [this.shadowMeshInput.width(), this.shadowMeshInput.height()];
-            return new THREE.WebGLRenderTarget(width, height, {
-                format: THREE.RGBAFormat,
-                encoding: THREE.LinearEncoding,
-                stencilBuffer: false,
-                // depthTexture: null!
-            });
-        });
-        this.uniforms = {
-            uShadowMap: { value: this.shadowMeshInput.map() },
-            uTime: { value: 0 },
-        };
-        this.fsQuad = computed(() => {
-            const shader = this.shadowMeshInput.shader();
-            if (!shader)
-                return null;
-            return new FullScreenQuad(new THREE.ShaderMaterial({
-                uniforms: this.uniforms,
-                vertexShader: /* glsl */ `
-          varying vec2 vUv;
-
-          void main() {
-            vUv = uv;
-            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-          }
-        `,
-                fragmentShader: shader,
-            }));
-        });
-        effect(() => {
-            this.shadowMeshInput.inputs.patch({
-                distance: 0.4,
-                alphaTest: 0.5,
-                width: 512,
-                height: 512,
-                scale: 4,
-                shader: /* glsl */ `
-          varying vec2 vUv;
-
-          uniform sampler2D uShadowMap;
-          uniform float uTime;
-
-          void main() {
-            vec3 color = texture2D(uShadowMap, vUv).xyz;
-            gl_FragColor = vec4(color, 1.);
-          }
-        `,
-            });
-        });
-        injectShadowMeshCommon(this.spotLightApi.spotLight, this.meshRef, this.shadowMeshInput.width, this.shadowMeshInput.height, this.shadowMeshInput.distance);
-        injectBeforeRender(({ delta, gl }) => {
-            this.uniforms.uTime.value += delta;
-            const fsQuad = this.fsQuad();
-            const renderTarget = this.renderTarget();
-            if (fsQuad && renderTarget) {
-                gl.setRenderTarget(renderTarget);
-                fsQuad.render(gl);
-                gl.setRenderTarget(null);
-            }
-        });
-        effect(() => {
-            const map = this.shadowMeshInput.map();
-            if (map) {
-                this.uniforms.uShadowMap.value = map;
-            }
-        });
-        effect((onCleanup) => {
-            const fsQuad = this.fsQuad();
-            onCleanup(() => {
-                if (fsQuad) {
-                    fsQuad.dispose();
-                    fsQuad.material.dispose();
-                }
-            });
-        });
-        effect((onCleanup) => {
-            const renderTarget = this.renderTarget();
-            onCleanup(() => {
-                renderTarget.dispose();
-            });
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadowMeshShader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSpotLightShadowMeshShader, isStandalone: true, selector: "ngts-spot-light-shadow-mesh-shader", ngImport: i0, template: `
-		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
-			<ngt-plane-geometry />
-			<ngt-mesh-basic-material
-				[transparent]="true"
-				[side]="DoubleSide"
-				[alphaTest]="shadowMeshInput.alphaTest()"
-				[alphaMap]="renderTarget().texture"
-				[opacity]="debug() ? 1 : 0"
-			>
-				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapS" />
-				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapT" />
-				<ng-content />
-			</ngt-mesh-basic-material>
-		</ngt-mesh>
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadowMeshShader, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-spot-light-shadow-mesh-shader',
-                    standalone: true,
-                    template: `
-		<ngt-mesh [ref]="meshRef" [scale]="shadowMeshInput.scale()" [castShadow]="true">
-			<ngt-plane-geometry />
-			<ngt-mesh-basic-material
-				[transparent]="true"
-				[side]="DoubleSide"
-				[alphaTest]="shadowMeshInput.alphaTest()"
-				[alphaMap]="renderTarget().texture"
-				[opacity]="debug() ? 1 : 0"
-			>
-				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapS" />
-				<ngt-value [rawValue]="RepeatWrapping" attach="alphaMap.wrapT" />
-				<ng-content />
-			</ngt-mesh-basic-material>
-		</ngt-mesh>
-	`,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; } });
-class NgtsSpotLightShadow extends NgtsSpotLightShadowMeshInput {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadow, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsSpotLightShadow, isStandalone: true, selector: "ngts-spot-light-shadow", providers: [{ provide: NgtsSpotLightShadowMeshInput, useExisting: NgtsSpotLightShadow }], usesInheritance: true, ngImport: i0, template: `
-		<ngts-spot-light-shadow-mesh-shader *ngIf="shader(); else noShader" />
-		<ng-template #noShader>
-			<ngts-spot-light-shadow-mesh-no-shader />
-		</ng-template>
-	`, isInline: true, dependencies: [{ kind: "component", type: NgtsSpotLightShadowMeshShader, selector: "ngts-spot-light-shadow-mesh-shader" }, { kind: "component", type: NgtsSpotLightShadowMeshNoShader, selector: "ngts-spot-light-shadow-mesh-no-shader" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsSpotLightShadow, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-spot-light-shadow',
-                    standalone: true,
-                    template: `
-		<ngts-spot-light-shadow-mesh-shader *ngIf="shader(); else noShader" />
-		<ng-template #noShader>
-			<ngts-spot-light-shadow-mesh-no-shader />
-		</ng-template>
-	`,
-                    imports: [NgtsSpotLightShadowMeshShader, NgtsSpotLightShadowMeshNoShader, NgIf],
-                    providers: [{ provide: NgtsSpotLightShadowMeshInput, useExisting: NgtsSpotLightShadow }],
-                }]
-        }] });
-
-const presets = {
-    rembrandt: {
-        main: [1, 2, 1],
-        fill: [-2, -0.5, -2],
-    },
-    portrait: {
-        main: [-1, 2, 0.5],
-        fill: [-1, 0.5, -1.5],
-    },
-    upfront: {
-        main: [0, 2, 1],
-        fill: [-1, 0.5, -1.5],
-    },
-    soft: {
-        main: [-2, 4, 4],
-        fill: [-1, 0.5, -1.5],
-    },
-};
-extend({ AmbientLight, SpotLight, Vector2, PointLight, Group });
-class NgtsStageRefit {
-    constructor() {
-        this.boundsApi = injectNgtsBoundsApi();
-        this.radius = 0;
-        this.adjustCamera = true;
-    }
-    ngOnChanges() {
-        if (this.adjustCamera) {
-            this.boundsApi().refresh().clip().fit();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsStageRefit, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsStageRefit, isStandalone: true, selector: "ngts-stage-refit", inputs: { radius: "radius", adjustCamera: "adjustCamera" }, usesOnChanges: true, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsStageRefit, decorators: [{
-            type: Directive,
-            args: [{ selector: 'ngts-stage-refit', standalone: true }]
-        }], propDecorators: { radius: [{
-                type: Input
-            }], adjustCamera: [{
-                type: Input
-            }] } });
-class NgtsStage {
-    constructor() {
-        this.Number = Number;
-        this.inputs = signalStore({
-            adjustCamera: true,
-            intensity: 0.5,
-            shadows: 'contact',
-            environment: 'city',
-            preset: 'rembrandt',
-        });
-        this.centered = new EventEmitter();
-        this.preset = this.inputs.select('preset');
-        this.environment = this.inputs.select('environment');
-        this.boundingState = signalStore({ radius: 0, width: 0, height: 0, depth: 0 });
-        this.config = computed(() => {
-            const preset = this.preset();
-            return typeof preset === 'string' ? presets[preset] : preset;
-        });
-        this.shadows = this.inputs.select('shadows');
-        this.intensity = this.inputs.select('intensity');
-        this.adjustCamera = this.inputs.select('adjustCamera');
-        this.center = this.inputs.select('center');
-        this.shadowsState = computed(() => {
-            const shadows = this.shadows();
-            const { bias: shadowBias = -0.0001, normalBias = 0, size: shadowSize = 1024, offset: shadowOffset = 0, ...restProps } = (typeof shadows === 'string' ? {} : shadows || {});
-            return {
-                contactShadow: shadows === 'contact' || restProps.type === 'contact',
-                accumulativeShadow: shadows === 'accumulative' || restProps.type === 'accumulative',
-                shadowBias,
-                normalBias,
-                shadowSize,
-                shadowOffset,
-                ...restProps,
-            };
-        });
-        this.environmentState = computed(() => {
-            const environment = this.environment();
-            return !environment ? null : typeof environment === 'string' ? { preset: environment } : environment;
-        });
-    }
-    set _preset(preset) {
-        this.inputs.set({ preset });
-    }
-    set _shadows(shadows) {
-        this.inputs.set({ shadows });
-    }
-    set _adjustCamera(adjustCamera) {
-        this.inputs.set({ adjustCamera });
-    }
-    set _environment(environment) {
-        this.inputs.set({ environment });
-    }
-    set _intensity(intensity) {
-        this.inputs.set({ intensity });
-    }
-    set _center(center) {
-        this.inputs.set({ center });
-    }
-    onCentered($event) {
-        const { width, height, depth, boundingSphere } = $event;
-        this.boundingState.set({ radius: boundingSphere.radius, width, height, depth });
-        if (this.centered.observed)
-            this.centered.emit($event);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsStage, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsStage, isStandalone: true, selector: "ngts-stage", inputs: { _preset: ["preset", "_preset"], _shadows: ["shadows", "_shadows"], _adjustCamera: ["adjustCamera", "_adjustCamera"], _environment: ["environment", "_environment"], _intensity: ["intensity", "_intensity"], _center: ["center", "_center"] }, outputs: { centered: "centered" }, ngImport: i0, template: `
-		<ngt-ambient-light [intensity]="intensity() / 3" />
-		<ngt-spot-light
-			[penumbra]="1"
-			[position]="[
-				config().main[0] * boundingState.get('radius'),
-				config().main[1] * boundingState.get('radius'),
-				config().main[2] * boundingState.get('radius')
-			]"
-			[intensity]="intensity() * 2"
-			[castShadow]="!!shadows()"
-		>
-			<ngt-value [rawValue]="shadowsState().shadowBias" attach="shadow.bias" />
-			<ngt-value [rawValue]="shadowsState().normalBias" attach="shadow.normalBias" />
-			<ngt-vector2 *args="[shadowsState().shadowSize, shadowsState().shadowSize]" attach="shadow.mapSize" />
-		</ngt-spot-light>
-		<ngt-point-light
-			[position]="[
-				config().fill[0] * boundingState.get('radius'),
-				config().fill[1] * boundingState.get('radius'),
-				config().fill[2] * boundingState.get('radius')
-			]"
-			[intensity]="intensity()"
-		/>
-
-		<ngts-bounds
-			[fit]="!!adjustCamera()"
-			[clip]="!!adjustCamera()"
-			[margin]="Number(adjustCamera())"
-			[observe]="true"
-		>
-			<ngts-stage-refit [radius]="boundingState.get('radius')" [adjustCamera]="adjustCamera()" />
-			<ngts-center
-				[position]="[0, shadowsState().shadowOffset / 2, 0]"
-				[top]="!!center()?.top"
-				[right]="!!center()?.right"
-				[bottom]="!!center()?.bottom"
-				[left]="!!center()?.left"
-				[front]="!!center()?.front"
-				[back]="!!center()?.back"
-				[disableX]="!!center()?.disableX"
-				[disableY]="!!center()?.disableY"
-				[disableZ]="!!center()?.disableZ"
-				[precise]="!!center()?.precise"
-				(centered)="onCentered($event)"
-			>
-				<ng-content />
-			</ngts-center>
-		</ngts-bounds>
-
-		<ngt-group [position]="[0, -boundingState.get('height') / 2 - shadowsState().shadowOffset / 2, 0]">
-			<ngts-contact-shadows
-				*ngIf="shadowsState().contactShadow"
-				[scale]="boundingState.get('radius') * 4"
-				[far]="boundingState.get('radius')"
-				[blur]="2"
-				[opacity]="shadowsState().opacity!"
-				[width]="shadowsState().width!"
-				[height]="shadowsState().height!"
-				[smooth]="shadowsState().smooth!"
-				[resolution]="shadowsState().resolution!"
-				[frames]="shadowsState().frames!"
-				[scale]="shadowsState().scale!"
-				[color]="shadowsState().color!"
-				[depthWrite]="shadowsState().depthWrite!"
-				[renderOrder]="shadowsState().renderOrder!"
-			/>
-			<ngts-accumulative-shadows
-				*ngIf="shadowsState().accumulativeShadow"
-				[temporal]="true"
-				[frames]="100"
-				[alphaTest]="0.9"
-				[toneMapped]="true"
-				[scale]="boundingState.get('radius') * 4"
-				[opacity]="shadowsState().opacity!"
-				[alphaTest]="shadowsState().alphaTest!"
-				[color]="shadowsState().color!"
-				[colorBlend]="shadowsState().colorBlend!"
-				[resolution]="shadowsState().resolution!"
-			>
-				<ngts-randomized-lights
-					[amount]="shadowsState().amount ?? 8"
-					[radius]="shadowsState().radius ?? boundingState.get('radius')"
-					[ambient]="shadowsState().ambient ?? 0.5"
-					[intensity]="shadowsState().intensity ?? 1"
-					[position]="[
-						config().main[0] * boundingState.get('radius'),
-						config().main[1] * boundingState.get('radius'),
-						config().main[2] * boundingState.get('radius')
-					]"
-					[size]="boundingState.get('radius') * 4"
-					[bias]="-shadowsState().shadowBias"
-					[mapSize]="shadowsState().shadowSize"
-				/>
-			</ngts-accumulative-shadows>
-		</ngt-group>
-
-		<ngts-environment
-			*ngIf="environmentState() as environment"
-			[frames]="environment.frames"
-			[near]="environment.near"
-			[far]="environment.far"
-			[resolution]="environment.resolution"
-			[background]="environment.background"
-			[blur]="environment.blur"
-			[map]="environment.map"
-			[files]="environment.files"
-			[path]="environment.path"
-			[preset]="environment.preset"
-			[scene]="environment.scene"
-			[extensions]="environment.extensions"
-			[ground]="environment.ground"
-			[encoding]="environment.encoding"
-		/>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: NgtsBounds, selector: "ngts-bounds", inputs: ["boundsRef", "damping", "fit", "clip", "observe", "margin", "eps"], outputs: ["fitted"] }, { kind: "directive", type: NgtsStageRefit, selector: "ngts-stage-refit", inputs: ["radius", "adjustCamera"] }, { kind: "component", type: NgtsCenter, selector: "ngts-center", inputs: ["centerRef", "top", "right", "bottom", "left", "front", "back", "disableX", "disableY", "disableZ", "disable", "precise", "cacheKey"], outputs: ["centered"] }, { kind: "component", type: NgtsContactShadows, selector: "ngts-contact-shadows", inputs: ["contactShadowsRef", "opacity", "width", "height", "blur", "far", "smooth", "resolution", "frames", "scale", "color", "depthWrite", "renderOrder"] }, { kind: "component", type: NgtsAccumulativeShadows, selector: "ngts-accumulative-shadows", inputs: ["accumulativeShadowsRef", "frames", "blend", "limit", "scale", "temporal", "opacity", "alphaTest", "color", "colorBlend", "resolution", "toneMapped"] }, { kind: "component", type: NgtsRandomizedLights, selector: "ngts-randomized-lights", inputs: ["lightsRef", "frames", "position", "radius", "amount", "intensity", "ambient", "castShadow", "bias", "mapSize", "size", "near", "far"] }, { kind: "component", type: NgtsEnvironment, selector: "ngts-environment" }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsStage, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-stage',
-                    standalone: true,
-                    template: `
-		<ngt-ambient-light [intensity]="intensity() / 3" />
-		<ngt-spot-light
-			[penumbra]="1"
-			[position]="[
-				config().main[0] * boundingState.get('radius'),
-				config().main[1] * boundingState.get('radius'),
-				config().main[2] * boundingState.get('radius')
-			]"
-			[intensity]="intensity() * 2"
-			[castShadow]="!!shadows()"
-		>
-			<ngt-value [rawValue]="shadowsState().shadowBias" attach="shadow.bias" />
-			<ngt-value [rawValue]="shadowsState().normalBias" attach="shadow.normalBias" />
-			<ngt-vector2 *args="[shadowsState().shadowSize, shadowsState().shadowSize]" attach="shadow.mapSize" />
-		</ngt-spot-light>
-		<ngt-point-light
-			[position]="[
-				config().fill[0] * boundingState.get('radius'),
-				config().fill[1] * boundingState.get('radius'),
-				config().fill[2] * boundingState.get('radius')
-			]"
-			[intensity]="intensity()"
-		/>
-
-		<ngts-bounds
-			[fit]="!!adjustCamera()"
-			[clip]="!!adjustCamera()"
-			[margin]="Number(adjustCamera())"
-			[observe]="true"
-		>
-			<ngts-stage-refit [radius]="boundingState.get('radius')" [adjustCamera]="adjustCamera()" />
-			<ngts-center
-				[position]="[0, shadowsState().shadowOffset / 2, 0]"
-				[top]="!!center()?.top"
-				[right]="!!center()?.right"
-				[bottom]="!!center()?.bottom"
-				[left]="!!center()?.left"
-				[front]="!!center()?.front"
-				[back]="!!center()?.back"
-				[disableX]="!!center()?.disableX"
-				[disableY]="!!center()?.disableY"
-				[disableZ]="!!center()?.disableZ"
-				[precise]="!!center()?.precise"
-				(centered)="onCentered($event)"
-			>
-				<ng-content />
-			</ngts-center>
-		</ngts-bounds>
-
-		<ngt-group [position]="[0, -boundingState.get('height') / 2 - shadowsState().shadowOffset / 2, 0]">
-			<ngts-contact-shadows
-				*ngIf="shadowsState().contactShadow"
-				[scale]="boundingState.get('radius') * 4"
-				[far]="boundingState.get('radius')"
-				[blur]="2"
-				[opacity]="shadowsState().opacity!"
-				[width]="shadowsState().width!"
-				[height]="shadowsState().height!"
-				[smooth]="shadowsState().smooth!"
-				[resolution]="shadowsState().resolution!"
-				[frames]="shadowsState().frames!"
-				[scale]="shadowsState().scale!"
-				[color]="shadowsState().color!"
-				[depthWrite]="shadowsState().depthWrite!"
-				[renderOrder]="shadowsState().renderOrder!"
-			/>
-			<ngts-accumulative-shadows
-				*ngIf="shadowsState().accumulativeShadow"
-				[temporal]="true"
-				[frames]="100"
-				[alphaTest]="0.9"
-				[toneMapped]="true"
-				[scale]="boundingState.get('radius') * 4"
-				[opacity]="shadowsState().opacity!"
-				[alphaTest]="shadowsState().alphaTest!"
-				[color]="shadowsState().color!"
-				[colorBlend]="shadowsState().colorBlend!"
-				[resolution]="shadowsState().resolution!"
-			>
-				<ngts-randomized-lights
-					[amount]="shadowsState().amount ?? 8"
-					[radius]="shadowsState().radius ?? boundingState.get('radius')"
-					[ambient]="shadowsState().ambient ?? 0.5"
-					[intensity]="shadowsState().intensity ?? 1"
-					[position]="[
-						config().main[0] * boundingState.get('radius'),
-						config().main[1] * boundingState.get('radius'),
-						config().main[2] * boundingState.get('radius')
-					]"
-					[size]="boundingState.get('radius') * 4"
-					[bias]="-shadowsState().shadowBias"
-					[mapSize]="shadowsState().shadowSize"
-				/>
-			</ngts-accumulative-shadows>
-		</ngt-group>
-
-		<ngts-environment
-			*ngIf="environmentState() as environment"
-			[frames]="environment.frames"
-			[near]="environment.near"
-			[far]="environment.far"
-			[resolution]="environment.resolution"
-			[background]="environment.background"
-			[blur]="environment.blur"
-			[map]="environment.map"
-			[files]="environment.files"
-			[path]="environment.path"
-			[preset]="environment.preset"
-			[scene]="environment.scene"
-			[extensions]="environment.extensions"
-			[ground]="environment.ground"
-			[encoding]="environment.encoding"
-		/>
-	`,
-                    imports: [
-                        NgtArgs,
-                        NgIf,
-                        NgtsBounds,
-                        NgtsStageRefit,
-                        NgtsCenter,
-                        NgtsContactShadows,
-                        NgtsAccumulativeShadows,
-                        NgtsRandomizedLights,
-                        NgtsEnvironment,
-                    ],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], propDecorators: { _preset: [{
-                type: Input,
-                args: [{ alias: 'preset' }]
-            }], _shadows: [{
-                type: Input,
-                args: [{ alias: 'shadows' }]
-            }], _adjustCamera: [{
-                type: Input,
-                args: [{ alias: 'adjustCamera' }]
-            }], _environment: [{
-                type: Input,
-                args: [{ alias: 'environment' }]
-            }], _intensity: [{
-                type: Input,
-                args: [{ alias: 'intensity' }]
-            }], _center: [{
-                type: Input,
-                args: [{ alias: 'center' }]
-            }], centered: [{
-                type: Output
-            }] } });
-
-extend({ Points, BufferGeometry, BufferAttribute });
-const genStar = (r) => new THREE.Vector3().setFromSpherical(new THREE.Spherical(r, Math.acos(1 - Math.random() * 2), Math.random() * 2 * Math.PI));
-class NgtsStars {
-    constructor() {
-        this.inputs = signalStore({
-            radius: 100,
-            depth: 50,
-            count: 5000,
-            saturation: 0,
-            factor: 4,
-            fade: false,
-            speed: 1,
-        });
-        this.AdditiveBlending = THREE.AdditiveBlending;
-        this.material = new StarFieldMaterial();
-        this.starsRef = injectNgtRef();
-        this.count = this.inputs.select('count');
-        this.depth = this.inputs.select('depth');
-        this.factor = this.inputs.select('factor');
-        this.radius = this.inputs.select('radius');
-        this.saturation = this.inputs.select('saturation');
-        this.fade = this.inputs.select('fade');
-        this.attributes = computed(() => {
-            const positions = [];
-            const colors = [];
-            const sizes = Array.from({ length: this.count() }, () => (0.5 + 0.5 * Math.random()) * this.factor());
-            const color = new THREE.Color();
-            let r = this.radius() + this.depth();
-            const increment = this.depth() / this.count();
-            for (let i = 0; i < this.count(); i++) {
-                r -= increment * Math.random();
-                positions.push(...genStar(r).toArray());
-                color.setHSL(i / this.count(), this.saturation(), 0.9);
-                colors.push(color.r, color.g, color.b);
-            }
-            return {
-                positions: new Float32Array(positions),
-                colors: new Float32Array(colors),
-                sizes: new Float32Array(sizes),
-            };
-        });
-    }
-    set _radius(radius) {
-        this.inputs.set({ radius });
-    }
-    set _depth(depth) {
-        this.inputs.set({ depth });
-    }
-    set _count(count) {
-        this.inputs.set({ count });
-    }
-    set _factor(factor) {
-        this.inputs.set({ factor });
-    }
-    set _saturation(saturation) {
-        this.inputs.set({ saturation });
-    }
-    set starsFade(fade) {
-        this.inputs.set({ fade });
-    }
-    set _speed(speed) {
-        this.inputs.set({ speed });
-    }
-    onBeforeRender({ object, state }) {
-        object.uniforms['time'].value = state.clock.getElapsedTime() * this.inputs.get('speed');
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsStars, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsStars, isStandalone: true, selector: "ngts-stars", inputs: { starsRef: "starsRef", _radius: ["radius", "_radius"], _depth: ["depth", "_depth"], _count: ["count", "_count"], _factor: ["factor", "_factor"], _saturation: ["saturation", "_saturation"], starsFade: ["fade", "starsFade"], _speed: ["speed", "_speed"] }, ngImport: i0, template: `
-		<ngt-points [ref]="starsRef">
-			<ngt-buffer-geometry>
-				<ngt-buffer-attribute attach="attributes.position" *args="[attributes().positions, 3]" />
-				<ngt-buffer-attribute attach="attributes.color" *args="[attributes().colors, 3]" />
-				<ngt-buffer-attribute attach="attributes.size" *args="[attributes().sizes, 1]" />
-			</ngt-buffer-geometry>
-			<ngt-primitive
-				*args="[material]"
-				attach="material"
-				[blending]="AdditiveBlending"
-				[depthWrite]="false"
-				[transparent]="true"
-				[vertexColors]="true"
-				(beforeRender)="onBeforeRender($event)"
-			>
-				<ngt-value attach="uniforms.fade.value" [rawValue]="fade()" />
-			</ngt-primitive>
-		</ngt-points>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsStars, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-stars',
-                    standalone: true,
-                    template: `
-		<ngt-points [ref]="starsRef">
-			<ngt-buffer-geometry>
-				<ngt-buffer-attribute attach="attributes.position" *args="[attributes().positions, 3]" />
-				<ngt-buffer-attribute attach="attributes.color" *args="[attributes().colors, 3]" />
-				<ngt-buffer-attribute attach="attributes.size" *args="[attributes().sizes, 1]" />
-			</ngt-buffer-geometry>
-			<ngt-primitive
-				*args="[material]"
-				attach="material"
-				[blending]="AdditiveBlending"
-				[depthWrite]="false"
-				[transparent]="true"
-				[vertexColors]="true"
-				(beforeRender)="onBeforeRender($event)"
-			>
-				<ngt-value attach="uniforms.fade.value" [rawValue]="fade()" />
-			</ngt-primitive>
-		</ngt-points>
-	`,
-                    imports: [NgtArgs],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], propDecorators: { starsRef: [{
-                type: Input
-            }], _radius: [{
-                type: Input,
-                args: [{ alias: 'radius' }]
-            }], _depth: [{
-                type: Input,
-                args: [{ alias: 'depth' }]
-            }], _count: [{
-                type: Input,
-                args: [{ alias: 'count' }]
-            }], _factor: [{
-                type: Input,
-                args: [{ alias: 'factor' }]
-            }], _saturation: [{
-                type: Input,
-                args: [{ alias: 'saturation' }]
-            }], starsFade: [{
-                type: Input,
-                args: ['fade']
-            }], _speed: [{
-                type: Input,
-                args: [{ alias: 'speed' }]
-            }] } });
-
-class NgtsWireframeInput {
-    constructor() {
-        this.inputs = signalStore({
-            simplify: false,
-            strokeOpacity: 1,
-            fillOpacity: 0.25,
-            fillMix: 0,
-            thickness: 0.05,
-            colorBackfaces: false,
-            dashInvert: true,
-            dash: false,
-            dashRepeats: 4,
-            dashLength: 0.5,
-            squeeze: false,
-            squeezeMin: 0.2,
-            squeezeMax: 1,
-            stroke: new THREE.Color('#ff0000'),
-            backfaceStroke: new THREE.Color('#0000ff'),
-            fill: new THREE.Color('#00ff00'),
-        });
-        this.simplify = this.inputs.select('simplify');
-        this.geometry = this.inputs.select('geometry');
-        this.customGeometry = computed(() => {
-            const geometry = this.geometry();
-            return is.ref(geometry) ? geometry.nativeElement : geometry;
-        });
-        this.strokeOpacity = this.inputs.select('strokeOpacity');
-        this.fillOpacity = this.inputs.select('fillOpacity');
-        this.fillMix = this.inputs.select('fillMix');
-        this.thickness = this.inputs.select('thickness');
-        this.colorBackfaces = this.inputs.select('colorBackfaces');
-        this.dashInvert = this.inputs.select('dashInvert');
-        this.dash = this.inputs.select('dash');
-        this.dashRepeats = this.inputs.select('dashRepeats');
-        this.dashLength = this.inputs.select('dashLength');
-        this.squeeze = this.inputs.select('squeeze');
-        this.squeezeMin = this.inputs.select('squeezeMin');
-        this.squeezeMax = this.inputs.select('squeezeMax');
-        this.stroke = this.inputs.select('stroke');
-        this.backfaceStroke = this.inputs.select('backfaceStroke');
-        this.fill = this.inputs.select('fill');
-        this.materialState = computed(() => {
-            const [strokeOpacity, fillOpacity, fillMix, thickness, colorBackfaces, dashInvert, dash, dashRepeats, dashLength, squeeze, squeezeMin, squeezeMax, stroke, backfaceStroke, fill,] = [
-                this.strokeOpacity(),
-                this.fillOpacity(),
-                this.fillMix(),
-                this.thickness(),
-                this.colorBackfaces(),
-                this.dashInvert(),
-                this.dash(),
-                this.dashRepeats(),
-                this.dashLength(),
-                this.squeeze(),
-                this.squeezeMin(),
-                this.squeezeMax(),
-                this.stroke(),
-                this.backfaceStroke(),
-                this.fill(),
-            ];
-            return {
-                strokeOpacity,
-                fillOpacity,
-                fillMix,
-                thickness,
-                colorBackfaces,
-                dashInvert,
-                dash,
-                dashRepeats,
-                dashLength,
-                squeeze,
-                squeezeMin,
-                squeezeMax,
-                stroke,
-                backfaceStroke,
-                fill,
-            };
-        });
-    }
-    set _geometry(geometry) {
-        this.inputs.set({ geometry });
-    }
-    set _simplify(simplify) {
-        this.inputs.set({ simplify });
-    }
-    set _fillOpacity(fillOpacity) {
-        this.inputs.set({ fillOpacity });
-    }
-    set _fillMix(fillMix) {
-        this.inputs.set({ fillMix });
-    }
-    set _strokeOpacity(strokeOpacity) {
-        this.inputs.set({ strokeOpacity });
-    }
-    set _thickness(thickness) {
-        this.inputs.set({ thickness });
-    }
-    set _colorBackfaces(colorBackfaces) {
-        this.inputs.set({ colorBackfaces });
-    }
-    set _dashInvert(dashInvert) {
-        this.inputs.set({ dashInvert });
-    }
-    set _dash(dash) {
-        this.inputs.set({ dash });
-    }
-    set _dashRepeats(dashRepeats) {
-        this.inputs.set({ dashRepeats });
-    }
-    set _dashLength(dashLength) {
-        this.inputs.set({ dashLength });
-    }
-    set _squeeze(squeeze) {
-        this.inputs.set({ squeeze });
-    }
-    set _squeezeMin(squeezeMin) {
-        this.inputs.set({ squeezeMin });
-    }
-    set _squeezeMax(squeezeMax) {
-        this.inputs.set({ squeezeMax });
-    }
-    set _stroke(stroke) {
-        this.inputs.set({ stroke });
-    }
-    set _backfaceStroke(backfaceStroke) {
-        this.inputs.set({ backfaceStroke });
-    }
-    set _fill(fill) {
-        this.inputs.set({ fill });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframeInput, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.2", type: NgtsWireframeInput, inputs: { _geometry: ["geometry", "_geometry"], _simplify: ["simplify", "_simplify"], _fillOpacity: ["fillOpacity", "_fillOpacity"], _fillMix: ["fillMix", "_fillMix"], _strokeOpacity: ["strokeOpacity", "_strokeOpacity"], _thickness: ["thickness", "_thickness"], _colorBackfaces: ["colorBackfaces", "_colorBackfaces"], _dashInvert: ["dashInvert", "_dashInvert"], _dash: ["dash", "_dash"], _dashRepeats: ["dashRepeats", "_dashRepeats"], _dashLength: ["dashLength", "_dashLength"], _squeeze: ["squeeze", "_squeeze"], _squeezeMin: ["squeezeMin", "_squeezeMin"], _squeezeMax: ["squeezeMax", "_squeezeMax"], _stroke: ["stroke", "_stroke"], _backfaceStroke: ["backfaceStroke", "_backfaceStroke"], _fill: ["fill", "_fill"] }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframeInput, decorators: [{
-            type: Directive
-        }], propDecorators: { _geometry: [{
-                type: Input,
-                args: [{ alias: 'geometry' }]
-            }], _simplify: [{
-                type: Input,
-                args: [{ alias: 'simplify' }]
-            }], _fillOpacity: [{
-                type: Input,
-                args: [{ alias: 'fillOpacity' }]
-            }], _fillMix: [{
-                type: Input,
-                args: [{ alias: 'fillMix' }]
-            }], _strokeOpacity: [{
-                type: Input,
-                args: [{ alias: 'strokeOpacity' }]
-            }], _thickness: [{
-                type: Input,
-                args: [{ alias: 'thickness' }]
-            }], _colorBackfaces: [{
-                type: Input,
-                args: [{ alias: 'colorBackfaces' }]
-            }], _dashInvert: [{
-                type: Input,
-                args: [{ alias: 'dashInvert' }]
-            }], _dash: [{
-                type: Input,
-                args: [{ alias: 'dash' }]
-            }], _dashRepeats: [{
-                type: Input,
-                args: [{ alias: 'dashRepeats' }]
-            }], _dashLength: [{
-                type: Input,
-                args: [{ alias: 'dashLength' }]
-            }], _squeeze: [{
-                type: Input,
-                args: [{ alias: 'squeeze' }]
-            }], _squeezeMin: [{
-                type: Input,
-                args: [{ alias: 'squeezeMin' }]
-            }], _squeezeMax: [{
-                type: Input,
-                args: [{ alias: 'squeezeMax' }]
-            }], _stroke: [{
-                type: Input,
-                args: [{ alias: 'stroke' }]
-            }], _backfaceStroke: [{
-                type: Input,
-                args: [{ alias: 'backfaceStroke' }]
-            }], _fill: [{
-                type: Input,
-                args: [{ alias: 'fill' }]
-            }] } });
-
-extend({ WireframeMaterial, Object3D });
-function isWithGeometry(object) {
-    return !!object?.geometry;
-}
-function isWireframeGeometry(geometry) {
-    return geometry.type === 'WireframeGeometry';
-}
-function getUniforms() {
-    const u = {};
-    for (const key in WireframeMaterialShaders.uniforms) {
-        u[key] = { value: WireframeMaterialShaders.uniforms[key] };
-    }
-    return u;
-}
-function getBarycentricCoordinates(geometry, removeEdge) {
-    const position = geometry.getAttribute('position');
-    const count = position.count;
-    const barycentric = [];
-    for (let i = 0; i < count; i++) {
-        const even = i % 2 === 0;
-        const Q = removeEdge ? 1 : 0;
-        if (even) {
-            barycentric.push(0, 0, 1, 0, 1, 0, 1, 0, Q);
-        }
-        else {
-            barycentric.push(0, 1, 0, 0, 0, 1, 1, 0, Q);
-        }
-    }
-    return new THREE.BufferAttribute(Float32Array.from(barycentric), 3);
-}
-function getInputGeometry(inputGeometry) {
-    const geo = (is.ref(inputGeometry) ? inputGeometry.nativeElement : inputGeometry);
-    if (!is.geometry(geo)) {
-        // Disallow WireframeGeometry
-        if (isWireframeGeometry(geo)) {
-            throw new Error('Wireframe: WireframeGeometry is not supported.');
-        }
-        const parent = geo.parent;
-        if (isWithGeometry(parent)) {
-            // Disallow WireframeGeometry
-            if (isWireframeGeometry(parent.geometry)) {
-                throw new Error('Wireframe: WireframeGeometry is not supported.');
-            }
-            return parent.geometry;
-        }
-    }
-    else {
-        return geo;
-    }
-    return;
-}
-function setBarycentricCoordinates(geometry, simplify) {
-    if (geometry.index) {
-        console.warn('[NGT]: ngts-wireframe requires non-indexed geometry, converting to non-indexed geometry.');
-        const nonIndexedGeo = geometry.toNonIndexed();
-        geometry.copy(nonIndexedGeo);
-        geometry.setIndex(null);
-    }
-    const newBarycentric = getBarycentricCoordinates(geometry, simplify);
-    geometry.setAttribute('barycentric', newBarycentric);
-}
-class NgtsWireframeWithoutCustomGeometry {
-    constructor() {
-        this.objectRef = injectNgtRef();
-        this.wireframeInput = inject(NgtsWireframeInput);
-        this.uniforms = getUniforms();
-        injectNgtsWireframeUniforms(() => this.uniforms, this.wireframeInput.materialState);
-        effect((onCleanup) => {
-            const object = this.objectRef.nativeElement;
-            if (!object)
-                return;
-            const simplify = this.wireframeInput.simplify();
-            const geometry = getInputGeometry(object);
-            if (!geometry) {
-                throw new Error('[NGT]: ngts-wireframe must be a child of a Mesh, Line or Points object or specify a geometry prop.');
-            }
-            const cloned = geometry.clone();
-            setBarycentricCoordinates(geometry, simplify);
-            onCleanup(() => {
-                geometry.copy(cloned);
-                cloned.dispose();
-            });
-        });
-        effect((onCleanup) => {
-            const object = this.objectRef.nativeElement;
-            if (!object)
-                return;
-            const parentMesh = object.parent;
-            const cloned = parentMesh.material.clone();
-            setWireframeOverride(parentMesh.material, this.uniforms);
-            onCleanup(() => {
-                parentMesh.material.dispose();
-                parentMesh.material = cloned;
-            });
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframeWithoutCustomGeometry, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsWireframeWithoutCustomGeometry, isStandalone: true, selector: "ngts-wireframe-without-custom-geometry", ngImport: i0, template: `
-		<ngt-object3D [ref]="objectRef" />
-	`, isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframeWithoutCustomGeometry, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-wireframe-without-custom-geometry',
-                    standalone: true,
-                    template: `
-		<ngt-object3D [ref]="objectRef" />
-	`,
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; } });
-class NgtsWireframeWithCustomGeometry {
-    constructor() {
-        this.DoubleSide = THREE.DoubleSide;
-        this.wireframeInput = inject(NgtsWireframeInput);
-        this.drawnGeometry = signal(this.wireframeInput.customGeometry());
-        effect(() => {
-            const [simplify, customGeometry] = [this.wireframeInput.simplify(), this.wireframeInput.geometry()];
-            const geometry = getInputGeometry(customGeometry);
-            if (!geometry) {
-                throw new Error('[NGT]: ngts-wireframe [geometry] input must be a BufferGeometry or a ref to a BufferGeometry.');
-            }
-            setBarycentricCoordinates(geometry, simplify);
-            if (is.ref(customGeometry)) {
-                untracked(() => this.drawnGeometry.set(geometry));
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframeWithCustomGeometry, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsWireframeWithCustomGeometry, isStandalone: true, selector: "ngts-wireframe-with-custom-geometry", ngImport: i0, template: `
-		<ngt-mesh *ngIf="drawnGeometry() as geometry" [geometry]="geometry">
-			<ngt-wireframe-material
-				attach="material"
-				[transparent]="true"
-				[side]="DoubleSide"
-				[polygonOffset]="true"
-				[polygonOffsetFactor]="-4"
-				[extensions]="{ derivatives: true, fragDepth: false, drawBuffers: false, shaderTextureLOD: false }"
-				[strokeOpacity]="wireframeInput.strokeOpacity()"
-				[fillOpacity]="wireframeInput.fillOpacity()"
-				[fillMix]="wireframeInput.fillMix()"
-				[thickness]="wireframeInput.thickness()"
-				[colorBackfaces]="wireframeInput.colorBackfaces()"
-				[dashInvert]="wireframeInput.dashInvert()"
-				[dash]="wireframeInput.dash()"
-				[dashRepeats]="wireframeInput.dashRepeats()"
-				[dashLength]="wireframeInput.dashLength()"
-				[squeeze]="wireframeInput.squeeze()"
-				[squeezeMin]="wireframeInput.squeezeMin()"
-				[squeezeMax]="wireframeInput.squeezeMax()"
-				[stroke]="wireframeInput.stroke()"
-				[backfaceStroke]="wireframeInput.backfaceStroke()"
-				[fill]="wireframeInput.fill()"
-			/>
-		</ngt-mesh>
-	`, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframeWithCustomGeometry, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-wireframe-with-custom-geometry',
-                    standalone: true,
-                    template: `
-		<ngt-mesh *ngIf="drawnGeometry() as geometry" [geometry]="geometry">
-			<ngt-wireframe-material
-				attach="material"
-				[transparent]="true"
-				[side]="DoubleSide"
-				[polygonOffset]="true"
-				[polygonOffsetFactor]="-4"
-				[extensions]="{ derivatives: true, fragDepth: false, drawBuffers: false, shaderTextureLOD: false }"
-				[strokeOpacity]="wireframeInput.strokeOpacity()"
-				[fillOpacity]="wireframeInput.fillOpacity()"
-				[fillMix]="wireframeInput.fillMix()"
-				[thickness]="wireframeInput.thickness()"
-				[colorBackfaces]="wireframeInput.colorBackfaces()"
-				[dashInvert]="wireframeInput.dashInvert()"
-				[dash]="wireframeInput.dash()"
-				[dashRepeats]="wireframeInput.dashRepeats()"
-				[dashLength]="wireframeInput.dashLength()"
-				[squeeze]="wireframeInput.squeeze()"
-				[squeezeMin]="wireframeInput.squeezeMin()"
-				[squeezeMax]="wireframeInput.squeezeMax()"
-				[stroke]="wireframeInput.stroke()"
-				[backfaceStroke]="wireframeInput.backfaceStroke()"
-				[fill]="wireframeInput.fill()"
-			/>
-		</ngt-mesh>
-	`,
-                    imports: [NgIf],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                }]
-        }], ctorParameters: function () { return []; } });
-class NgtsWireframe extends NgtsWireframeInput {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframe, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtsWireframe, isStandalone: true, selector: "ngts-wireframe", providers: [{ provide: NgtsWireframeInput, useExisting: NgtsWireframe }], usesInheritance: true, ngImport: i0, template: `
-		<ngts-wireframe-with-custom-geometry *ngIf="geometry(); else withoutCustomGeometry" />
-		<ng-template #withoutCustomGeometry>
-			<ngts-wireframe-without-custom-geometry />
-		</ng-template>
-	`, isInline: true, dependencies: [{ kind: "component", type: NgtsWireframeWithoutCustomGeometry, selector: "ngts-wireframe-without-custom-geometry" }, { kind: "component", type: NgtsWireframeWithCustomGeometry, selector: "ngts-wireframe-with-custom-geometry" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtsWireframe, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ngts-wireframe',
-                    standalone: true,
-                    template: `
-		<ngts-wireframe-with-custom-geometry *ngIf="geometry(); else withoutCustomGeometry" />
-		<ng-template #withoutCustomGeometry>
-			<ngts-wireframe-without-custom-geometry />
-		</ng-template>
-	`,
-                    imports: [NgtsWireframeWithoutCustomGeometry, NgtsWireframeWithCustomGeometry, NgIf],
-                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
-                    providers: [{ provide: NgtsWireframeInput, useExisting: NgtsWireframe }],
-                }]
-        }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { ENVIRONMENT_PRESETS, NgtsAccumulativeShadows, NgtsBBAnchor, NgtsBackdrop, NgtsBounds, NgtsCameraShake, NgtsCenter, NgtsCloud, NgtsContactShadows, NgtsEnvironment, NgtsFloat, NgtsRandomizedLights, NgtsSky, NgtsSparkles, NgtsSpotLight, NgtsSpotLightShadow, NgtsStage, NgtsStageRefit, NgtsStars, NgtsWireframe, NgtsWireframeWithCustomGeometry, NgtsWireframeWithoutCustomGeometry, injectNgtsAccumulativeShadowsApi, injectNgtsBoundsApi, injectNgtsMatcapTexture, injectNgtsNormalTexture, injectNgtsSpotLightApi, provideNgtsAccumulativeShadowsApi, provideNgtsBoundsApi, provideNgtsSpotLightApi };
-//# sourceMappingURL=angular-three-soba-staging.mjs.map