angular-three 0.0.2 → 0.0.3

package/fesm2020/angular-three.mjs

@@ -1,22 +1,2356 @@
+import { DOCUMENT, NgIf, NgTemplateOutlet, AsyncPipe } from '@angular/common';
 import * as i0 from '@angular/core';
-import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
+import { Injectable, InjectionToken, inject, NgZone, EventEmitter, Directive, Input, Output, ElementRef, Component, TemplateRef, ChangeDetectionStrategy, HostBinding, ViewChild, ContentChild, ViewContainerRef, Injector } from '@angular/core';
+import * as THREE from 'three';
+import { BehaviorSubject, filter, noop, tap, isObservable, combineLatest, Observable, Subject, pipe, debounceTime, takeUntil, fromEvent, share, ReplaySubject, from, retry, catchError, of, forkJoin, map } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
 
-class AngularThreeModule {
+function getInstanceLocalState(obj) {
+    if (!obj)
+        return undefined;
+    return obj['__ngt__'];
 }
-AngularThreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: AngularThreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularThreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.0", ngImport: i0, type: AngularThreeModule, imports: [CommonModule] });
-AngularThreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: AngularThreeModule, imports: [CommonModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: AngularThreeModule, decorators: [{
-            type: NgModule,
+
+const idCache = {};
+function makeId(event) {
+    if (event) {
+        return (event.eventObject || event.object).uuid + '/' + event.index + event.instanceId;
+    }
+    const newId = THREE.MathUtils.generateUUID();
+    // ensure not already used
+    if (!idCache[newId]) {
+        idCache[newId] = true;
+        return newId;
+    }
+    return makeId();
+}
+function makeDpr(dpr, window) {
+    const target = window?.devicePixelRatio || 1;
+    return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
+}
+function make(type, input) {
+    if (!input)
+        return new type();
+    if (input instanceof type) {
+        return input;
+    }
+    if (!Array.isArray(input)) {
+        input = typeof input === 'number' ? [input, input, input, input] : [input];
+    }
+    return new type(...input);
+}
+
+/**
+ * Release pointer captures.
+ * This is called by releasePointerCapture in the API, and when an object is removed.
+ */
+function releaseInternalPointerCapture(capturedMap, obj, captures, pointerId) {
+    const captureData = captures.get(obj);
+    if (captureData) {
+        captures.delete(obj);
+        // If this was the last capturing object for this pointer
+        if (captures.size === 0) {
+            capturedMap.delete(pointerId);
+            captureData.target.releasePointerCapture(pointerId);
+        }
+    }
+}
+function removeInteractivity(stateFactory, object) {
+    const { internal } = stateFactory();
+    // Removes every trace of an object from the data store
+    internal.interaction = internal.interaction.filter((o) => o !== object);
+    internal.initialHits = internal.initialHits.filter((o) => o !== object);
+    internal.hovered.forEach((value, key) => {
+        if (value.eventObject === object || value.object === object) {
+            // Clear out intersects, they are outdated by now
+            internal.hovered.delete(key);
+        }
+    });
+    internal.capturedMap.forEach((captures, pointerId) => {
+        releaseInternalPointerCapture(internal.capturedMap, object, captures, pointerId);
+    });
+}
+function createEvents(stateFactory) {
+    /** Calculates delta */
+    function calculateDistance(event) {
+        const { internal } = stateFactory();
+        const dx = event.offsetX - internal.initialClick[0];
+        const dy = event.offsetY - internal.initialClick[1];
+        return Math.round(Math.sqrt(dx * dx + dy * dy));
+    }
+    /** Returns true if an instance has a valid pointer-event registered, this excludes scroll, clicks etc */
+    function filterPointerEvents(objects) {
+        return objects.filter((obj) => ['move', 'over', 'enter', 'out', 'leave'].some((name) => {
+            const eventName = ('pointer' + name);
+            return getInstanceLocalState(obj)?.handlers[eventName];
+        }));
+    }
+    function intersect(event, filter) {
+        const state = stateFactory();
+        const duplicates = new Set();
+        const intersections = [];
+        // Allow callers to eliminate event objects
+        const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction;
+        // Reset all raycaster cameras to undefined
+        for (let i = 0; i < eventsObjects.length; i++) {
+            const instanceState = getInstanceLocalState(eventsObjects[i])?.stateFactory();
+            if (instanceState) {
+                instanceState.raycaster.camera = undefined;
+            }
+        }
+        if (!state.previousStateFactory) {
+            // Make sure root-level pointer and ray are set up
+            state.events.compute?.(event, () => state);
+        }
+        function handleRaycast(obj) {
+            const state = getInstanceLocalState(obj)?.stateFactory();
+            // Skip event handling when noEvents is set, or when the raycasters camera is null
+            if (!state || !state.events.enabled || state.raycaster.camera === null)
+                return [];
+            // When the camera is undefined we have to call the event layers update function
+            if (state.raycaster.camera === undefined) {
+                state.events.compute?.(event, () => state, state.previousStateFactory);
+                // If the camera is still undefined we have to skip this layer entirely
+                if (state.raycaster.camera === undefined)
+                    state.raycaster.camera = null;
+            }
+            // Intersect object by object
+            return state.raycaster.camera ? state.raycaster.intersectObject(obj, true) : [];
+        }
+        // Collect events
+        let hits = eventsObjects
+            // Intersect objects
+            .flatMap(handleRaycast)
+            // Sort by event priority and distance
+            .sort((a, b) => {
+            const aState = getInstanceLocalState(a.object)?.stateFactory();
+            const bState = getInstanceLocalState(b.object)?.stateFactory();
+            if (!aState || !bState)
+                return 0;
+            return bState.events.priority - aState.events.priority || a.distance - b.distance;
+        })
+            // Filter out duplicates
+            .filter((item) => {
+            const id = makeId(item);
+            if (duplicates.has(id))
+                return false;
+            duplicates.add(id);
+            return true;
+        });
+        // https://github.com/mrdoob/three.js/issues/16031
+        // Allow custom userland intersect sort order, this likely only makes sense on the root filter
+        if (state.events.filter)
+            hits = state.events.filter(hits, () => state);
+        // Bubble up the events, find the event source (eventObject)
+        for (const hit of hits) {
+            let eventObject = hit.object;
+            // Bubble event up
+            while (eventObject) {
+                if (getInstanceLocalState(eventObject)?.eventCount)
+                    intersections.push({ ...hit, eventObject });
+                eventObject = eventObject.parent;
+            }
+        }
+        // If the interaction is captured, make all capturing targets part of the intersect.
+        if ('pointerId' in event && state.internal.capturedMap.has(event.pointerId)) {
+            for (const captureData of state.internal.capturedMap.get(event.pointerId).values()) {
+                intersections.push(captureData.intersection);
+            }
+        }
+        return intersections;
+    }
+    /**  Handles intersections by forwarding them to handlers */
+    function handleIntersects(intersections, event, delta, callback) {
+        const rootState = stateFactory();
+        // If anything has been found, forward it to the event listeners
+        if (intersections.length) {
+            const localState = { stopped: false };
+            for (const hit of intersections) {
+                const state = getInstanceLocalState(hit.object)?.stateFactory() || rootState;
+                const { raycaster, pointer, camera, internal } = state;
+                const unprojectedPoint = new THREE.Vector3(pointer.x, pointer.y, 0).unproject(camera);
+                const hasPointerCapture = (id) => internal.capturedMap.get(id)?.has(hit.eventObject) ?? false;
+                const setPointerCapture = (id) => {
+                    const captureData = {
+                        intersection: hit,
+                        target: event.target,
+                    };
+                    if (internal.capturedMap.has(id)) {
+                        // if the pointerId was previously captured, we add the hit to the
+                        // event capturedMap.
+                        internal.capturedMap.get(id).set(hit.eventObject, captureData);
+                    }
+                    else {
+                        // if the pointerId was not previously captured, we create a map
+                        // containing the hitObject, and the hit. hitObject is used for
+                        // faster access.
+                        internal.capturedMap.set(id, new Map([[hit.eventObject, captureData]]));
+                    }
+                    // Call the original event now
+                    event.target.setPointerCapture(id);
+                };
+                const releasePointerCapture = (id) => {
+                    const captures = internal.capturedMap.get(id);
+                    if (captures) {
+                        releaseInternalPointerCapture(internal.capturedMap, hit.eventObject, captures, id);
+                    }
+                };
+                // Add native event props
+                const extractEventProps = {};
+                // This iterates over the event's properties including the inherited ones. Native PointerEvents have most of their props as getters which are inherited, but polyfilled PointerEvents have them all as their own properties (i.e. not inherited). We can't use Object.keys() or Object.entries() as they only return "own" properties; nor Object.getPrototypeOf(event) as that *doesn't* return "own" properties, only inherited ones.
+                for (const prop in event) {
+                    const property = event[prop];
+                    // Only copy over atomics, leave functions alone as these should be
+                    // called as event.nativeEvent.fn()
+                    if (typeof property !== 'function')
+                        extractEventProps[prop] = property;
+                }
+                const raycastEvent = {
+                    ...hit,
+                    ...extractEventProps,
+                    pointer,
+                    intersections,
+                    stopped: localState.stopped,
+                    delta,
+                    unprojectedPoint,
+                    ray: raycaster.ray,
+                    camera: camera,
+                    // Hijack stopPropagation, which just sets a flag
+                    stopPropagation() {
+                        // https://github.com/pmndrs/react-three-fiber/issues/596
+                        // Events are not allowed to stop propagation if the pointer has been captured
+                        const capturesForPointer = 'pointerId' in event && internal.capturedMap.get(event.pointerId);
+                        // We only authorize stopPropagation...
+                        if (
+                        // ...if this pointer hasn't been captured
+                        !capturesForPointer ||
+                            // ... or if the hit object is capturing the pointer
+                            capturesForPointer.has(hit.eventObject)) {
+                            raycastEvent.stopped = localState.stopped = true;
+                            // Propagation is stopped, remove all other hover records
+                            // An event handler is only allowed to flush other handlers if it is hovered itself
+                            if (internal.hovered.size &&
+                                Array.from(internal.hovered.values()).find((i) => i.eventObject === hit.eventObject)) {
+                                // Objects cannot flush out higher up objects that have already caught the event
+                                const higher = intersections.slice(0, intersections.indexOf(hit));
+                                cancelPointer([...higher, hit]);
+                            }
+                        }
+                    },
+                    // there should be a distinction between target and currentTarget
+                    target: {
+                        hasPointerCapture,
+                        setPointerCapture,
+                        releasePointerCapture,
+                    },
+                    currentTarget: {
+                        hasPointerCapture,
+                        setPointerCapture,
+                        releasePointerCapture,
+                    },
+                    nativeEvent: event,
+                };
+                // Call subscribers
+                callback(raycastEvent);
+                // Event bubbling may be interrupted by stopPropagation
+                if (localState.stopped === true)
+                    break;
+            }
+        }
+        return intersections;
+    }
+    function cancelPointer(intersections) {
+        const { internal } = stateFactory();
+        for (const hoveredObj of internal.hovered.values()) {
+            // When no objects were hit or the hovered object wasn't found underneath the cursor
+            // we call onPointerOut and delete the object from the hovered-elements map
+            if (!intersections.length ||
+                !intersections.find((hit) => hit.object === hoveredObj.object &&
+                    hit.index === hoveredObj.index &&
+                    hit.instanceId === hoveredObj.instanceId)) {
+                const eventObject = hoveredObj.eventObject;
+                const instance = getInstanceLocalState(eventObject);
+                const handlers = instance?.handlers;
+                internal.hovered.delete(makeId(hoveredObj));
+                if (instance?.eventCount) {
+                    // Clear out intersects, they are outdated by now
+                    const data = { ...hoveredObj, intersections };
+                    handlers?.pointerout?.(data);
+                    handlers?.pointerleave?.(data);
+                }
+            }
+        }
+    }
+    function pointerMissed(event, objects) {
+        for (let i = 0; i < objects.length; i++) {
+            const instance = getInstanceLocalState(objects[i]);
+            instance?.handlers.pointermissed?.(event);
+        }
+    }
+    function handlePointer(name) {
+        // Deal with cancelation
+        switch (name) {
+            case 'pointerleave':
+            case 'pointercancel':
+                return () => cancelPointer([]);
+            case 'lostpointercapture':
+                return (event) => {
+                    const { internal } = stateFactory();
+                    if ('pointerId' in event && !internal.capturedMap.has(event.pointerId)) {
+                        // If the object event interface had onLostPointerCapture, we'd call it here on every
+                        // object that's getting removed.
+                        internal.capturedMap.delete(event.pointerId);
+                        cancelPointer([]);
+                    }
+                };
+        }
+        // Any other pointer goes here ...
+        return function handleEvent(event) {
+            const { onPointerMissed, internal } = stateFactory();
+            // prepareRay(event)
+            internal.lastEvent = event;
+            // Get fresh intersects
+            const isPointerMove = name === 'pointermove';
+            const isClickEvent = name === 'click' || name === 'contextmenu' || name === 'dblclick';
+            const filter = isPointerMove ? filterPointerEvents : undefined;
+            // const hits = patchIntersects(intersect(filter), event)
+            const hits = intersect(event, filter);
+            const delta = isClickEvent ? calculateDistance(event) : 0;
+            // Save initial coordinates on pointer-down
+            if (name === 'pointerdown') {
+                internal.initialClick = [event.offsetX, event.offsetY];
+                internal.initialHits = hits.map((hit) => hit.eventObject);
+            }
+            // If a click yields no results, pass it back to the user as a miss
+            // Missed events have to come first in order to establish user-land side-effect clean up
+            if (isClickEvent && !hits.length) {
+                if (delta <= 2) {
+                    pointerMissed(event, internal.interaction);
+                    if (onPointerMissed)
+                        onPointerMissed(event);
+                }
+            }
+            // Take care of unhover
+            if (isPointerMove)
+                cancelPointer(hits);
+            function onIntersect(data) {
+                const eventObject = data.eventObject;
+                const instance = getInstanceLocalState(eventObject);
+                const handlers = instance?.handlers;
+                // Check presence of handlers
+                if (!instance?.eventCount)
+                    return;
+                if (isPointerMove) {
+                    // Move event ...
+                    if (handlers?.pointerover ||
+                        handlers?.pointerenter ||
+                        handlers?.pointerout ||
+                        handlers?.pointerleave) {
+                        // When enter or out is present take care of hover-state
+                        const id = makeId(data);
+                        const hoveredItem = internal.hovered.get(id);
+                        if (!hoveredItem) {
+                            // If the object wasn't previously hovered, book it and call its handler
+                            internal.hovered.set(id, data);
+                            handlers.pointerover?.(data);
+                            handlers.pointerenter?.(data);
+                        }
+                        else if (hoveredItem.stopped) {
+                            // If the object was previously hovered and stopped, we shouldn't allow other items to proceed
+                            data.stopPropagation();
+                        }
+                    }
+                    // Call mouse move
+                    handlers?.pointermove?.(data);
+                }
+                else {
+                    // All other events ...
+                    const handler = handlers[name];
+                    if (handler) {
+                        // Forward all events back to their respective handlers with the exception of click events,
+                        // which must use the initial target
+                        if (!isClickEvent || internal.initialHits.includes(eventObject)) {
+                            // Missed events have to come first
+                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
+                            // Now call the handler
+                            handler(data);
+                        }
+                    }
+                    else {
+                        // Trigger onPointerMissed on all elements that have pointer over/out handlers, but not click and weren't hit
+                        if (isClickEvent && internal.initialHits.includes(eventObject)) {
+                            pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object)));
+                        }
+                    }
+                }
+            }
+            handleIntersects(hits, event, delta, onIntersect);
+        };
+    }
+    return { handlePointer };
+}
+
+const DOM_EVENTS = {
+    click: false,
+    contextmenu: false,
+    dblclick: false,
+    wheel: false,
+    pointerdown: true,
+    pointerup: true,
+    pointerleave: true,
+    pointermove: true,
+    pointercancel: true,
+    lostpointercapture: true,
+};
+function createPointerEvents(stateFactory) {
+    const { handlePointer } = createEvents(stateFactory);
+    return {
+        priority: 1,
+        enabled: true,
+        compute: (event, rootFactory) => {
+            const state = rootFactory();
+            // https://github.com/pmndrs/react-three-fiber/pull/782
+            // Events trigger outside of canvas when moved, use offsetX/Y by default and allow overrides
+            state.pointer.set((event.offsetX / state.size.width) * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1);
+            state.raycaster.setFromCamera(state.pointer, state.camera);
+        },
+        connected: undefined,
+        handlers: Object.keys(DOM_EVENTS).reduce((handlers, supportedEventName) => {
+            handlers[supportedEventName] = handlePointer(supportedEventName);
+            return handlers;
+        }, {}),
+        connect: (target) => {
+            const state = stateFactory();
+            state.events.disconnect?.();
+            state.setEvents({ connected: target });
+            Object.entries(state.events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
+                const passive = DOM_EVENTS[eventName];
+                target.addEventListener(eventName, eventHandler, { passive });
+            });
+        },
+        disconnect: () => {
+            const { events, setEvents } = stateFactory();
+            if (events.connected) {
+                Object.entries(events.handlers ?? {}).forEach(([eventName, eventHandler]) => {
+                    if (events.connected instanceof HTMLElement) {
+                        events.connected.removeEventListener(eventName, eventHandler);
+                    }
+                });
+                setEvents({ connected: undefined });
+            }
+        },
+    };
+}
+
+class NgtRef extends BehaviorSubject {
+    constructor(value) {
+        super(value ? value : null);
+    }
+    set(valueOrFactory) {
+        if (typeof valueOrFactory === 'function') {
+            this.next(valueOrFactory(this.value));
+        }
+        else {
+            this.next(valueOrFactory);
+        }
+    }
+}
+
+const is = {
+    obj: (a) => a === Object(a) && !Array.isArray(a) && typeof a !== 'function',
+    material: (a) => !!a && a.isMaterial,
+    geometry: (a) => !!a && a.isBufferGeometry,
+    mesh: (a) => !!a && a.isMesh,
+    color: (a) => !!a && a.isColor,
+    orthographic: (a) => !!a && a.isOrthographicCamera,
+    perspective: (a) => !!a && a.isPerspectiveCamera,
+    camera: (a) => !!a && a.isCamera,
+    glRenderer: (a) => !!a && a instanceof THREE.WebGLRenderer,
+    scene: (a) => !!a && a.isScene,
+    object3d: (a) => !!a && a.isObject3D,
+    instance: (a) => !!a && !!a['__ngt__'],
+    ref: (a) => !!a && a instanceof NgtRef,
+    supportColorManagement: () => 'ColorManagement' in THREE,
+    canvas: (a) => a instanceof HTMLCanvasElement,
+    equ(a, b, { arrays = 'shallow', objects = 'reference', strict = true } = {}) {
+        // Wrong type or one of the two undefined, doesn't match
+        if (typeof a !== typeof b || !!a !== !!b)
+            return false;
+        // Atomic, just compare a against b
+        if (typeof a === 'string' || typeof a === 'number')
+            return a === b;
+        const isObj = is.obj(a);
+        if (isObj && objects === 'reference')
+            return a === b;
+        const isArr = Array.isArray(a);
+        if (isArr && arrays === 'reference')
+            return a === b;
+        // Array or Object, shallow compare first to see if it's a match
+        if ((isArr || isObj) && a === b)
+            return true;
+        // Last resort, go through keys
+        let i;
+        for (i in a)
+            if (!(i in b))
+                return false;
+        for (i in strict ? b : a)
+            if (a[i] !== b[i])
+                return false;
+        if (i === void 0) {
+            if (isArr && a.length === 0 && b.length === 0)
+                return true;
+            if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0)
+                return true;
+            if (a !== b)
+                return false;
+        }
+        return true;
+    },
+};
+
+/**
+ * a default Selector that consumers can quickly use for their selectors projector
+ */
+const defaultProjector = () => ({});
+/**
+ * A custom operator that skips the first undefined value but allows subsequent undefined values.
+ * NgRxComponentStore#select always emits the first value regardless of undefined or not after initialize
+ */
+const skipFirstUndefined = () => filter((value, index) => index > 0 || value !== undefined);
+/**
+ * An extended `tap` operator that accepts an `effectFn` which:
+ * - runs on every `next` notification from `source$`
+ * - can optionally return a `cleanUp` function that
+ * invokes from the 2nd `next` notification onward and on `unsubscribe` (destroyed)
+ *
+ *
+ * @example
+ * ```typescript
+ * source$.pipe(
+ *  tapEffect((sourceValue) = {
+ *    const cb = () => {
+ *      doStuff(sourceValue);
+ *    };
+ *    addListener('event', cb);
+ *
+ *    return () => {
+ *      removeListener('event', cb);
+ *    }
+ *  })
+ * )
+ * ```
+ */
+function tapEffect(effectFn) {
+    let cleanupFn = noop;
+    let firstRun = false;
+    let prev = undefined;
+    const teardown = (error) => {
+        return () => {
+            if (cleanupFn) {
+                cleanupFn({ prev, complete: true, error });
+            }
+        };
+    };
+    return tap({
+        next: (value) => {
+            if (cleanupFn && firstRun) {
+                cleanupFn({ prev, complete: false, error: false });
+            }
+            const cleanUpOrVoid = effectFn(value);
+            if (cleanUpOrVoid) {
+                cleanupFn = cleanUpOrVoid;
+            }
+            prev = value;
+            if (!firstRun) {
+                firstRun = true;
+            }
+        },
+        complete: teardown(false),
+        unsubscribe: teardown(false),
+        error: teardown(true),
+    });
+}
+class NgtComponentStore extends ComponentStore {
+    constructor() {
+        super({});
+        // exposing get since THREE is imperative at its core
+        // we need to imperatively get state sometimes for usages in Animation Loop
+        // we also bind "this" instance, so we don't have to bind it later
+        this.read = this.get.bind(this);
+        this.initialize();
+    }
+    /**
+     * A custom patchState that allows for:
+     * - Partial state updates and Observable of partial state updates like patchState
+     * - Pass a Record<string, ObservableInput> to update a specific key with an Observable.
+     * This is similar to `RxState.connect()` API
+     */
+    write(partialStateOrFactory) {
+        if (typeof partialStateOrFactory === 'function') {
+            return this.write(partialStateOrFactory(this.read()));
+        }
+        const partialState = partialStateOrFactory;
+        if (Object.keys(partialState).length === 0) {
+            return;
+        }
+        if (isObservable(partialState)) {
+            return this.patchState(partialState);
+        }
+        const entries = Object.entries(partialState);
+        const hasObservable = entries.some(([_, value]) => isObservable(value) && !is.ref(value));
+        if (!hasObservable) {
+            return this.patchState(partialState);
+        }
+        const [rawValues, observableValues] = entries.reduce((result, [key, value]) => {
+            if (isObservable(value)) {
+                result[1][key] = value;
+            }
+            else {
+                result[0][key] = value;
+            }
+            return result;
+        }, [{}, {}]);
+        if (Object.keys(rawValues).length > 0) {
+            this.patchState(rawValues);
+        }
+        if (Object.keys(observableValues).length > 0) {
+            this.patchState(combineLatest(observableValues));
+        }
+    }
+    initialize() {
+        return;
+    }
+    /**
+     * A utility class method to select a state on the template as Observable
+     * - This method always debounce the Observable
+     */
+    selectKey(key, skipFirst = false) {
+        return this.select((s) => s[key], { debounce: true }).pipe(skipFirst ? skipFirstUndefined() : (s) => s);
+    }
+    /**
+     * A utility class method to get a state on the template as imperative Value
+     */
+    readKey(key) {
+        return this.read((s) => s[key]);
+    }
+}
+NgtComponentStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtComponentStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgtComponentStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtComponentStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtComponentStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+function createInjection(description, { defaultValueOrFactory, provideValueFactory, } = {}) {
+    const factory = (defaultValueOrFactory && typeof defaultValueOrFactory === 'function'
+        ? defaultValueOrFactory
+        : () => defaultValueOrFactory);
+    const injectionToken = new InjectionToken(description, { factory });
+    function injectFn(options = {}) {
+        return inject(injectionToken, options);
+    }
+    function provideFn(value) {
+        return {
+            provide: injectionToken,
+            useValue: provideValueFactory ? provideValueFactory(value) : value,
+        };
+    }
+    return [injectFn, provideFn, injectionToken];
+}
+
+const [injectWindow] = createInjection('window', {
+    defaultValueOrFactory: () => {
+        const { defaultView } = inject(DOCUMENT);
+        if (!defaultView) {
+            throw `window is not available!`;
+        }
+        return defaultView;
+    },
+});
+
+function checkNeedsUpdate(value) {
+    if (value !== null && is.obj(value) && 'needsUpdate' in value) {
+        value['needsUpdate'] = true;
+        if ('uniformsNeedUpdate' in value) {
+            value['uniformsNeedUpdate'] = true;
+        }
+    }
+}
+function checkUpdate(value) {
+    if (is.object3d(value)) {
+        value.updateMatrix();
+    }
+    else if (is.camera(value)) {
+        if (is.perspective(value) || is.orthographic(value)) {
+            value.updateProjectionMatrix();
+        }
+        value.updateMatrixWorld();
+    }
+    checkNeedsUpdate(value);
+}
+
+function invalidateInstance(instance) {
+    const state = getInstanceLocalState(instance)?.stateFactory();
+    if (state && state.internal.frames === 0)
+        state.invalidate();
+    checkUpdate(instance);
+}
+function prepare(instance, parentStateFactory, rootStateFactory, parentInstance, previousInstance, isPrimitive = false) {
+    const previousInstanceInternal = getInstanceLocalState(previousInstance?.value);
+    const parent = parentInstance
+        ? parentInstance
+        : previousInstanceInternal
+            ? previousInstanceInternal.parentRef
+            : undefined;
+    if (is.scene(instance)) {
+        applyProps(instance, { dispose: null });
+    }
+    return Object.assign(instance, {
+        __ngt__: {
+            stateFactory: parentStateFactory,
+            rootFactory: rootStateFactory,
+            isPrimitive: !isPrimitive ? previousInstanceInternal?.isPrimitive : isPrimitive,
+            eventCount: previousInstanceInternal?.eventCount ?? 0,
+            handlers: previousInstanceInternal?.handlers ?? {},
+            instancesRefs: previousInstanceInternal?.instancesRefs ?? new NgtRef([]),
+            objectsRefs: previousInstanceInternal?.objectsRefs ?? new NgtRef([]),
+            parentRef: parent ? (parent === instance || parent.value === instance ? null : parent) : null,
+        },
+    });
+}
+
+const DEFAULT = '__default';
+function diffProps(instance, props, previousProps = {}, remove = false) {
+    const localState = getInstanceLocalState(instance) || {};
+    const propsEntries = Object.entries(props);
+    const changes = [];
+    // Catch removed props, prepend them, so they can be reset or removed
+    if (remove) {
+        const previousKeys = Object.keys(previousProps);
+        for (const previousKey of previousKeys) {
+            // @ts-ignore
+            if (!Object.hasOwn(props, previousKey)) {
+                propsEntries.unshift([previousKey, DEFAULT + 'remove']);
+            }
+        }
+    }
+    for (const [propKey, propValue] of propsEntries) {
+        if (is.equ(propValue, previousProps[propKey]))
+            continue;
+        changes.push([propKey, propValue]);
+    }
+    const memoized = { ...props };
+    if (localState.memoized && localState.memoized['args']) {
+        memoized['args'] = localState.memoized['args'];
+    }
+    if (localState.memoized && localState.memoized['attach']) {
+        memoized['attach'] = localState.memoized['attach'] || localState.attach;
+    }
+    return { changes, memoized };
+}
+function applyProps(instance, props) {
+    // props is empty
+    if (!Object.keys(props).length)
+        return instance;
+    // Filter equals, events and reserved props
+    const localState = getInstanceLocalState(instance) || {};
+    const rootState = localState.stateFactory?.();
+    const { changes, memoized } = diffProps(instance, props);
+    const instanceHandlers = localState.eventCount;
+    if (getInstanceLocalState(instance)) {
+        getInstanceLocalState(instance).memoized = memoized;
+    }
+    for (let i = 0; i < changes.length; i++) {
+        const key = changes[i][0];
+        const currentInstance = instance;
+        const targetProp = currentInstance[key];
+        let value = changes[i][1];
+        if (is.ref(value)) {
+            value = value.value;
+        }
+        if (value === DEFAULT + 'remove') {
+            if (targetProp && targetProp.constructor) {
+                // use the prop constructor to find the default it should be
+                value = new targetProp.constructor(...(memoized['args'] ?? []));
+            }
+            else if (currentInstance.constructor) {
+                const dummyInstance = new currentInstance.constructor(...(getInstanceLocalState(currentInstance)?.memoized?.['args'] || []));
+                value = dummyInstance[targetProp];
+                // destroy the instance
+                if (dummyInstance.dispose)
+                    dummyInstance.dispose();
+            }
+            else {
+                value = 0;
+            }
+        }
+        // Special treatment for objects with support for set/copy, and layers
+        if (targetProp && targetProp['set'] && (targetProp['copy'] || targetProp instanceof THREE.Layers)) {
+            const isColor = targetProp instanceof THREE.Color;
+            // If value is an array
+            if (Array.isArray(value)) {
+                if (targetProp['fromArray'])
+                    targetProp['fromArray'](value);
+                else
+                    targetProp['set'](...value);
+            }
+            // Test again target.copy(class) next ...
+            else if (targetProp['copy'] &&
+                value &&
+                value.constructor &&
+                targetProp.constructor.name === value.constructor.name) {
+                targetProp['copy'](value);
+                if (!is.supportColorManagement() && !rootState.linear && isColor) {
+                    targetProp['convertSRGBToLinear']();
+                }
+            }
+            // If nothing else fits, just set the single value, ignore undefined
+            // https://github.com/pmndrs/react-three-fiber/issues/274
+            else if (value !== undefined) {
+                const isColor = targetProp instanceof THREE.Color;
+                // Allow setting array scalars
+                if (!isColor && targetProp['setScalar'])
+                    targetProp['setScalar'](value);
+                // Layers have no copy function, we must therefore copy the mask property
+                else if (targetProp instanceof THREE.Layers && value instanceof THREE.Layers)
+                    targetProp.mask = value.mask;
+                // Otherwise just set ...
+                else
+                    targetProp['set'](value);
+                // For versions of three which don't support THREE.ColorManagement,
+                // Auto-convert sRGB colors
+                // https://github.com/pmndrs/react-three-fiber/issues/344
+                if (!is.supportColorManagement() && !rootState.linear && isColor)
+                    targetProp.convertSRGBToLinear();
+            }
+            // Else, just overwrite the value
+        }
+        else {
+            currentInstance[key] = value;
+            // Auto-convert sRGB textures, for now ...
+            // https://github.com/pmndrs/react-three-fiber/issues/344
+            if (!rootState?.linear && currentInstance[key] instanceof THREE.Texture) {
+                currentInstance[key]['encoding'] = THREE.sRGBEncoding;
+            }
+        }
+        checkNeedsUpdate(targetProp);
+        invalidateInstance(instance);
+    }
+    if (localState.parentRef &&
+        rootState.internal &&
+        instance['raycast'] &&
+        instanceHandlers !== localState.eventCount) {
+        // Pre-emptively remove the instance from the interaction manager
+        rootState.removeInteraction(instance['uuid']);
+        // Add the instance to the interaction manager only when it has handlers
+        if (localState.eventCount)
+            rootState.addInteraction(instance);
+    }
+    return instance;
+}
+
+function updateCamera(camera, size) {
+    // https://github.com/pmndrs/react-three-fiber/issues/92
+    // Do not mess with the camera if it belongs to the user
+    if (!camera.manual) {
+        if (is.orthographic(camera)) {
+            camera.left = size.width / -2;
+            camera.right = size.width / 2;
+            camera.top = size.height / 2;
+            camera.bottom = size.height / -2;
+        }
+        else {
+            camera.aspect = size.width / size.height;
+        }
+        camera.updateProjectionMatrix();
+        // https://github.com/pmndrs/react-three-fiber/issues/178
+        // Update matrix world since the renderer is a frame late
+        camera.updateMatrixWorld();
+    }
+}
+function createDefaultCamera(isOrthographic, size) {
+    if (isOrthographic) {
+        return new THREE.OrthographicCamera(0, 0, 0, 0, 0.1, 1000);
+    }
+    return new THREE.PerspectiveCamera(75, size.width / size.height, 0.1, 1000);
+}
+
+function createSubs(callback, subs) {
+    const sub = { callback };
+    subs.add(sub);
+    return () => void subs.delete(sub);
+}
+const globalEffects = new Set();
+const globalAfterEffects = new Set();
+const globalTailEffects = new Set();
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+const addEffect = (callback) => createSubs(callback, globalEffects);
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+const addAfterEffect = (callback) => createSubs(callback, globalAfterEffects);
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+const addTail = (callback) => createSubs(callback, globalTailEffects);
+function run(effects, timestamp) {
+    if (!effects.size)
+        return;
+    for (const { callback } of effects.values()) {
+        callback(timestamp);
+    }
+}
+function flushGlobalEffects(type, timestamp) {
+    switch (type) {
+        case 'before':
+            return run(globalEffects, timestamp);
+        case 'after':
+            return run(globalAfterEffects, timestamp);
+        case 'tail':
+            return run(globalTailEffects, timestamp);
+    }
+}
+function render(timestamp, stateFactory, frame) {
+    const state = stateFactory();
+    // Run local effects
+    let delta = state.clock.getDelta();
+    // In frameloop='never' mode, clock times are updated using the provided timestamp
+    if (state.frameloop === 'never' && typeof timestamp === 'number') {
+        delta = timestamp - state.clock.elapsedTime;
+        state.clock.oldTime = state.clock.elapsedTime;
+        state.clock.elapsedTime = timestamp;
+    }
+    // Call subscribers (useFrame)
+    // subscribers = state.internal.subscribers;
+    for (let i = 0; i < state.internal.subscribers.length; i++) {
+        const subscriber = state.internal.subscribers[i];
+        const object = is.ref(subscriber.obj) ? subscriber.obj.value : subscriber.obj;
+        subscriber.callback({ ...state, delta, frame }, object);
+    }
+    // Render content
+    if (!state.internal.priority && state.gl.render)
+        state.gl.render(state.scene, state.camera);
+    // Decrease frame count
+    state.internal.frames = Math.max(0, state.internal.frames - 1);
+    return state.frameloop === 'always' ? 1 : state.internal.frames;
+}
+function createLoop(roots) {
+    let running = false;
+    let repeat;
+    let frame;
+    let state;
+    function loop(timestamp) {
+        frame = requestAnimationFrame(loop);
+        running = true;
+        repeat = 0;
+        // Run effects
+        flushGlobalEffects('before', timestamp);
+        // Render all roots
+        for (const root of roots.values()) {
+            state = root();
+            // If the frameloop is invalidated, do not run another frame
+            if (state.internal.active &&
+                (state.frameloop === 'always' || state.internal.frames > 0) &&
+                !state.gl.xr?.isPresenting) {
+                repeat += render(timestamp, root);
+            }
+        }
+        // Run after-effects
+        flushGlobalEffects('after', timestamp);
+        // Stop the loop if nothing invalidates it
+        if (repeat === 0) {
+            // Tail call effects, they are called when rendering stops
+            flushGlobalEffects('tail', timestamp);
+            // Flag end of operation
+            running = false;
+            return cancelAnimationFrame(frame);
+        }
+    }
+    function invalidate(stateFactory, frames = 1) {
+        const stateToInvalidate = stateFactory?.();
+        if (!stateToInvalidate)
+            return roots.forEach((root) => invalidate(root, frames));
+        if (stateToInvalidate.gl.xr?.isPresenting ||
+            !stateToInvalidate.internal.active ||
+            stateToInvalidate.frameloop === 'never')
+            return;
+        // Increase frames, do not go higher than 60
+        stateToInvalidate.internal.frames = Math.min(60, stateToInvalidate.internal.frames + frames);
+        // If the render-loop isn't active, start it
+        if (!running) {
+            running = true;
+            requestAnimationFrame(loop);
+        }
+    }
+    function advance(timestamp, runGlobalEffects = true, stateFactory, frame) {
+        if (runGlobalEffects)
+            flushGlobalEffects('before', timestamp);
+        if (!stateFactory)
+            for (const root of roots.values())
+                render(timestamp, root);
+        else
+            render(timestamp, stateFactory, frame);
+        if (runGlobalEffects)
+            flushGlobalEffects('after', timestamp);
+    }
+    return {
+        loop,
+        /**
+         * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+         */
+        invalidate,
+        /**
+         * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+         */
+        advance,
+    };
+}
+
+function createRenderer(glOptions, canvasElement) {
+    const customRenderer = (typeof glOptions === 'function' ? glOptions(canvasElement) : glOptions);
+    if (customRenderer?.render != null) {
+        return customRenderer;
+    }
+    return new THREE.WebGLRenderer({
+        powerPreference: 'high-performance',
+        canvas: canvasElement,
+        antialias: true,
+        alpha: true,
+        ...(glOptions || {}),
+    });
+}
+
+const rootStateMap = new Map();
+const { invalidate, advance } = createLoop(rootStateMap);
+const shallowLoose = { objects: 'shallow', strict: false };
+class NgtStore extends NgtComponentStore {
+    constructor() {
+        super(...arguments);
+        this.parentStore = inject(NgtStore, { optional: true, skipSelf: true });
+        this.zone = inject(NgZone);
+        this.window = injectWindow();
+        this.position = new THREE.Vector3();
+        this.defaultTarget = new THREE.Vector3();
+        this.tempTarget = new THREE.Vector3();
+        this.resize = this.effect(($) => {
+            let oldSize = this.read((s) => s.size);
+            let oldDpr = this.read((s) => s.viewport?.dpr);
+            return $.pipe(tap(() => {
+                const { camera, size, viewport, gl } = this.read();
+                // Resize camera and renderer on changes to size and pixelratio
+                if (size !== oldSize || viewport.dpr !== oldDpr) {
+                    oldSize = size;
+                    oldDpr = viewport.dpr;
+                    // Update camera & renderer
+                    updateCamera(camera, size);
+                    gl.setPixelRatio(viewport.dpr);
+                    gl.setSize(size.width, size.height, size.updateStyle);
+                }
+            }));
+        });
+        this.invalidate = this.effect(tap(() => void this.read((s) => s.invalidate)()));
+        this.isInit = false;
+        this.isConfigured = false;
+        this.addInteraction = (interaction) => {
+            this.write((state) => ({
+                ...state,
+                internal: {
+                    ...state.internal,
+                    interaction: [...state.internal.interaction, interaction],
+                },
+            }));
+        };
+        this.removeInteraction = (uuid) => {
+            this.write((state) => ({
+                ...state,
+                internal: {
+                    ...state.internal,
+                    interaction: state.internal.interaction.filter((interaction) => interaction.uuid !== uuid),
+                },
+            }));
+        };
+        this.setPerformanceCurrent = (current) => {
+            this.write((s) => ({ performance: { ...s.performance, current } }));
+        };
+        this.setEvents = (events) => {
+            this.write((s) => ({ events: { ...s.events, ...events } }));
+        };
+        this.setSize = (width, height, top, left, updateStyle) => {
+            const camera = this.read((s) => s.camera);
+            const size = { width, height, top: top || 0, left: left || 0, updateStyle };
+            this.write((state) => ({
+                size,
+                viewport: {
+                    ...state.viewport,
+                    ...this.getCurrentViewport(camera, this.defaultTarget, size),
+                },
+            }));
+        };
+        this.setCamera = (camera) => {
+            this.write((s) => ({
+                camera,
+                viewport: {
+                    ...s.viewport,
+                    ...this.getCurrentViewport(camera),
+                },
+            }));
+            this.read((s) => s.cameraRef).set(camera);
+        };
+        this.setDpr = (dpr) => {
+            const resolved = makeDpr(dpr, this.window);
+            this.write((s) => ({
+                viewport: {
+                    ...s.viewport,
+                    dpr: resolved,
+                    initialDpr: s.viewport.initialDpr || resolved,
+                },
+            }));
+        };
+        this.setFrameloop = (frameloop = 'always') => {
+            const clock = this.read((s) => s.clock);
+            // if frameloop === "never" clock.elapsedTime is updated using advance(timestamp)
+            clock.stop();
+            clock.elapsedTime = 0;
+            if (frameloop !== 'never') {
+                clock.start();
+                clock.elapsedTime = 0;
+            }
+            this.write({ frameloop });
+        };
+        this.getCurrentViewport = (camera = this.read((s) => s.camera), target = this.defaultTarget, size = this.read((s) => s.size)) => {
+            const { width, height, top, left } = size;
+            const aspect = width / height;
+            if (target instanceof THREE.Vector3)
+                this.tempTarget.copy(target);
+            else
+                this.tempTarget.set(...target);
+            const distance = camera.getWorldPosition(this.position).distanceTo(this.tempTarget);
+            if (is.orthographic(camera)) {
+                return {
+                    width: width / camera.zoom,
+                    height: height / camera.zoom,
+                    top,
+                    left,
+                    factor: 1,
+                    distance,
+                    aspect,
+                };
+            }
+            const fov = (camera.fov * Math.PI) / 180; // convert vertical fov to radians
+            const h = 2 * Math.tan(fov / 2) * distance; // visible height
+            const w = h * (width / height);
+            return {
+                width: w,
+                height: h,
+                top,
+                left,
+                factor: width / w,
+                distance,
+                aspect,
+            };
+        };
+    }
+    get rootStateFactory() {
+        let root = this.read((s) => s.previousStateFactory);
+        while (root && root().previousStateFactory) {
+            root = root().previousStateFactory;
+        }
+        return root || this.read;
+    }
+    init() {
+        if (!this.isInit) {
+            const pointer = new THREE.Vector2();
+            const scene = prepare(new THREE.Scene(), this.read, this.rootStateFactory, this.parentStore?.get((s) => s.sceneRef));
+            let performanceTimeout;
+            this.write({
+                ready: false,
+                cameraRef: new NgtRef(),
+                scene,
+                sceneRef: new NgtRef(scene),
+                events: { priority: 1, enabled: true, connected: false },
+                invalidate: (frames = 1) => invalidate(this.read, frames),
+                advance: (timestamp, runGlobalEffects) => advance(timestamp, runGlobalEffects, this.read),
+                legacy: false,
+                linear: false,
+                flat: false,
+                controls: null,
+                clock: new THREE.Clock(),
+                pointer,
+                frameloop: 'always',
+                performance: {
+                    current: 1,
+                    min: 0.5,
+                    max: 1,
+                    debounce: 200,
+                    regress: () => {
+                        this.zone.runOutsideAngular(() => {
+                            const state = this.read();
+                            // Clear timeout
+                            if (performanceTimeout)
+                                clearTimeout(performanceTimeout);
+                            // Set lower bound performance
+                            if (state.performance.current !== state.performance.min)
+                                this.setPerformanceCurrent(state.performance.min);
+                            // Go back to upper bound performance after a while unless something regresses meanwhile
+                            performanceTimeout = setTimeout(() => this.setPerformanceCurrent(this.read((s) => s.performance)?.max || 1), state.performance.debounce);
+                        });
+                    },
+                },
+                size: { width: 0, height: 0, top: 0, left: 0, updateStyle: false },
+                viewport: {
+                    initialDpr: 0,
+                    dpr: 0,
+                    width: 0,
+                    height: 0,
+                    top: 0,
+                    left: 0,
+                    aspect: 0,
+                    distance: 0,
+                    factor: 0,
+                    getCurrentViewport: this.getCurrentViewport,
+                },
+                previousStateFactory: this.parentStore?.read.bind(this.parentStore),
+                internal: {
+                    active: false,
+                    priority: 0,
+                    frames: 0,
+                    lastEvent: null,
+                    interaction: [],
+                    hovered: new Map(),
+                    capturedMap: new Map(),
+                    animations: new Map(),
+                    subscribers: [],
+                    initialClick: [0, 0],
+                    initialHits: [],
+                    subscribe: (callback, priority = 0, stateFactory = this.read, obj) => {
+                        const internal = this.read((s) => s.internal);
+                        // If this subscription was given a priority, it takes rendering into its own hands
+                        // For that reason we switch off automatic rendering and increase the manual flag
+                        // As long as this flag is positive there can be no internal rendering at all
+                        // because there could be multiple render subscriptions
+                        internal.priority = internal.priority + (priority > 0 ? 1 : 0);
+                        internal.subscribers.push({ priority, stateFactory, callback, obj });
+                        // Register subscriber and sort layers from lowest to highest, meaning,
+                        // highest priority renders last (on top of the other frames)
+                        internal.subscribers.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+                        return () => {
+                            const internalOnCleanUp = this.read((s) => s.internal);
+                            if (internalOnCleanUp.subscribers) {
+                                // Decrease manual flag if this subscription had a priority
+                                internalOnCleanUp.priority = internalOnCleanUp.priority - (priority > 0 ? 1 : 0);
+                                // Remove subscriber from list
+                                internalOnCleanUp.subscribers = internalOnCleanUp.subscribers.filter((s) => s.callback !== callback);
+                            }
+                        };
+                    },
+                },
+                setPerformanceCurrent: this.setPerformanceCurrent,
+                setEvents: this.setEvents,
+                setFrameloop: this.setFrameloop,
+                setSize: this.setSize,
+                setDpr: this.setDpr,
+                setCamera: this.setCamera,
+                addInteraction: this.addInteraction,
+                removeInteraction: this.removeInteraction,
+            });
+            this.isInit = true;
+        }
+    }
+    configure(inputs, canvasElement) {
+        const { gl: glOptions, size: sizeOptions, camera: cameraOptions, raycaster: raycasterOptions, events, orthographic, lookAt, shadows, linear, flat, legacy, dpr, frameloop, performance, } = inputs;
+        const state = this.read();
+        // Set up renderer (one time only!)
+        let gl = state.gl;
+        if (!state.gl) {
+            this.write({ gl: (gl = createRenderer(glOptions, canvasElement)) });
+        }
+        // Set up raycaster (one time only!)
+        let raycaster = state.raycaster;
+        if (!raycaster) {
+            this.write({ raycaster: (raycaster = new THREE.Raycaster()) });
+        }
+        // Set raycaster options
+        const { params, ...options } = raycasterOptions || {};
+        if (!is.equ(options, raycaster, shallowLoose)) {
+            applyProps(raycaster, { ...options });
+        }
+        if (!is.equ(params, raycaster.params, shallowLoose)) {
+            applyProps(raycaster, {
+                params: { ...raycaster.params, ...(params || {}) },
+            });
+        }
+        // Create default camera (one time only!)
+        if (!state.camera) {
+            const isCamera = is.camera(cameraOptions);
+            let camera = isCamera ? cameraOptions : createDefaultCamera(orthographic, state.size);
+            if (!isCamera) {
+                if (cameraOptions) {
+                    applyProps(camera, cameraOptions);
+                }
+                // Set position.z if position not passed in
+                if (!cameraOptions?.position) {
+                    camera.position.z = 5;
+                }
+                // Always look at center or passed-in lookAt by default
+                if (!cameraOptions?.rotation) {
+                    if (Array.isArray(lookAt)) {
+                        camera.lookAt(lookAt[0], lookAt[1], lookAt[2]);
+                    }
+                    else if (lookAt instanceof THREE.Vector3) {
+                        camera.lookAt(lookAt);
+                    }
+                    else {
+                        camera.lookAt(0, 0, 0);
+                    }
+                }
+                // Update projection matrix after applying props
+                camera.updateProjectionMatrix();
+            }
+            if (!is.instance(camera)) {
+                camera = prepare(camera, this.read, this.rootStateFactory, this.parentStore?.get((s) => s.cameraRef));
+            }
+            this.write({ camera });
+            this.read((s) => s.cameraRef).set(camera);
+        }
+        // Set up XR (one time only!)
+        if (!state.xr) {
+            // Handle frame behavior in WebXR
+            const handleXRFrame = (timestamp, frame) => {
+                const state = this.read();
+                if (state.frameloop === 'never')
+                    return;
+                advance(timestamp, true, this.read, frame);
+            };
+            // Toggle render switching on session
+            const handleSessionChange = () => {
+                const state = this.read();
+                state.gl.xr.enabled = state.gl.xr.isPresenting;
+                state.gl.xr.setAnimationLoop(state.gl.xr.isPresenting ? handleXRFrame : null);
+                if (!state.gl.xr.isPresenting)
+                    invalidate(this.read);
+            };
+            // WebXR session manager
+            const xr = {
+                connect: () => {
+                    const gl = this.read((s) => s.gl);
+                    gl.xr.addEventListener('sessionstart', handleSessionChange);
+                    gl.xr.addEventListener('sessionend', handleSessionChange);
+                },
+                disconnect: () => {
+                    const gl = this.read((s) => s.gl);
+                    gl.xr.removeEventListener('sessionstart', handleSessionChange);
+                    gl.xr.removeEventListener('sessionend', handleSessionChange);
+                },
+            };
+            // Subscribe to WebXR session events
+            if (gl.xr)
+                xr.connect();
+            this.write({ xr });
+        }
+        // Set shadowmap
+        if (gl.shadowMap) {
+            const isBoolean = typeof shadows === 'boolean';
+            if ((isBoolean && gl.shadowMap.enabled !== shadows) || !is.equ(shadows, gl.shadowMap, shallowLoose)) {
+                const old = gl.shadowMap.enabled;
+                gl.shadowMap.enabled = !!shadows;
+                if (!isBoolean)
+                    Object.assign(gl.shadowMap, shadows);
+                else
+                    gl.shadowMap.type = THREE.PCFSoftShadowMap;
+                if (old !== gl.shadowMap.enabled)
+                    checkNeedsUpdate(gl.shadowMap);
+            }
+        }
+        // Safely set color management if available.
+        // Avoid accessing THREE.ColorManagement to play nice with older versions
+        if (is.supportColorManagement()) {
+            THREE.ColorManagement.legacyMode = state.legacy;
+        }
+        const outputEncoding = linear ? THREE.LinearEncoding : THREE.sRGBEncoding;
+        const toneMapping = flat ? THREE.NoToneMapping : THREE.ACESFilmicToneMapping;
+        if (gl.outputEncoding !== outputEncoding)
+            gl.outputEncoding = outputEncoding;
+        if (gl.toneMapping !== toneMapping)
+            gl.toneMapping = toneMapping;
+        // Update color management state
+        if (state.legacy !== legacy)
+            this.write({ legacy });
+        if (state.linear !== linear)
+            this.write({ linear });
+        if (state.flat !== flat)
+            this.write({ flat });
+        // Set gl props
+        gl.setClearAlpha(0);
+        gl.setPixelRatio(makeDpr(state.viewport.dpr));
+        gl.setSize(state.size.width, state.size.height, state.size.updateStyle);
+        if (is.obj(glOptions) &&
+            !(typeof glOptions === 'function') &&
+            !is.glRenderer(glOptions) &&
+            !is.equ(glOptions, gl, shallowLoose)) {
+            applyProps(gl, glOptions);
+        }
+        // Store events internally
+        if (events && !state.events.handlers) {
+            this.write({ events: events(this.read) });
+        }
+        // Check pixelratio
+        if (dpr && state.viewport.dpr !== makeDpr(dpr)) {
+            state.setDpr(dpr);
+        }
+        // Check size, allow it to take on container bounds initially
+        const size = computeInitialSize(canvasElement, sizeOptions);
+        if (!is.equ(size, state.size, shallowLoose)) {
+            state.setSize(size.width, size.height, size.top, size.left);
+        }
+        // Check frameloop
+        if (state.frameloop !== frameloop)
+            state.setFrameloop(frameloop);
+        // Check performance
+        if (performance && !is.equ(performance, state.performance, shallowLoose)) {
+            this.write((state) => ({
+                performance: { ...state.performance, ...performance },
+            }));
+        }
+        this.write({ ready: true });
+        this.resize(this.select(this.select((s) => s.size), this.select((s) => s.viewport.dpr), defaultProjector, { debounce: true }));
+        this.invalidate(this.select((s) => s, { debounce: true }));
+        this.zone.run(() => {
+            this.isConfigured = true;
+        });
+    }
+    onReady(cb) {
+        return this.effect(tapEffect(cb))(this.select((s) => s.ready).pipe(filter((ready) => ready)));
+    }
+}
+NgtStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtStore, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+NgtStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtStore, decorators: [{
+            type: Injectable
+        }] });
+function computeInitialSize(canvas, defaultSize) {
+    if (defaultSize) {
+        return defaultSize;
+    }
+    if (is.canvas(canvas) && canvas.parentElement) {
+        const { width, height, top, left } = canvas.parentElement.getBoundingClientRect();
+        return { width, height, top, left };
+    }
+    return { width: 0, height: 0, top: 0, left: 0 };
+}
+
+function mutate(object, value, paths = []) {
+    const [base, ...remaining] = paths;
+    if (!base)
+        return;
+    if (remaining.length === 0) {
+        applyProps(object, { [base]: value });
+    }
+    else {
+        // assign an empty object in order to spread object if undefined
+        assignEmpty(object, base);
+        // recursion
+        mutate(object[base], value, remaining);
+    }
+}
+function assignEmpty(obj, base) {
+    if (
+    // @ts-ignore
+    (!Object.hasOwn(obj, base) && Reflect && !!Reflect.has && !Reflect.has(obj, base)) ||
+        obj[base] === undefined) {
+        obj[base] = {};
+    }
+}
+
+const NGT_PROXY_INSTANCE = Symbol.for('__ngt__proxy__instance__');
+const NGT_INSTANCE_REF_FACTORY = new InjectionToken('NgtInstance[instanceRef] factory');
+function provideInstanceRef(ctor, factory) {
+    return {
+        provide: NGT_INSTANCE_REF_FACTORY,
+        useFactory: (instance) => {
+            if (factory) {
+                return () => factory(instance);
+            }
+            return () => instance['instanceRef'] || instance['instance']['instanceRef'];
+        },
+        deps: [ctor],
+    };
+}
+function injectInstanceRef(options = {}) {
+    return inject(NGT_INSTANCE_REF_FACTORY, options);
+}
+function injectInstance(options = {}) {
+    return inject(NgtInstance, options);
+}
+const supportedEvents = [
+    'click',
+    'contextmenu',
+    'dblclick',
+    'pointerup',
+    'pointerdown',
+    'pointerover',
+    'pointerout',
+    'pointerenter',
+    'pointerleave',
+    'pointermove',
+    'pointermissed',
+    'pointercancel',
+    'wheel',
+];
+class NgtInstance extends NgtComponentStore {
+    constructor() {
+        super(...arguments);
+        this.priority = 0;
+        this.click = new EventEmitter();
+        this.contextmenu = new EventEmitter();
+        this.dblclick = new EventEmitter();
+        this.pointerup = new EventEmitter();
+        this.pointerdown = new EventEmitter();
+        this.pointerover = new EventEmitter();
+        this.pointerout = new EventEmitter();
+        this.pointerenter = new EventEmitter();
+        this.pointerleave = new EventEmitter();
+        this.pointermove = new EventEmitter();
+        this.pointermissed = new EventEmitter();
+        this.pointercancel = new EventEmitter();
+        this.wheel = new EventEmitter();
+        this.zone = inject(NgZone);
+        this.store = inject(NgtStore);
+        this.parentRef = injectInstanceRef({ skipSelf: true, optional: true });
+        this._isRaw = false;
+        this.hasEmittedAlready = false;
+        this.instanceReady = this.effect(tapEffect(() => {
+            this.handleEvents();
+            let attachToParentSubscription;
+            if (this.parentRef) {
+                attachToParentSubscription = this.attachToParent(this.parent.pipe(filter((parent) => !!parent)));
+            }
+            let beforeRenderCleanUp;
+            if (this.beforeRender && is.object3d(this.instanceValue) && is.object3d(this.proxyInstance)) {
+                beforeRenderCleanUp = this.store
+                    .read((s) => s.internal)
+                    .subscribe((state, object) => this.beforeRender(state, object), this.priority, this.store.read, this.proxyInstance);
+            }
+            if (this.readyCallback)
+                this.readyCallback(this.instanceValue);
+            return () => {
+                beforeRenderCleanUp?.();
+                attachToParentSubscription?.unsubscribe();
+            };
+        }));
+        this.handleEvents = this.effect(tapEffect(() => {
+            if (this.instanceValue && is.object3d(this.instanceValue)) {
+                const observedEvents = supportedEvents.reduce((result, event) => {
+                    const controllerEvent = this[event].observed ? this[event] : null;
+                    if (controllerEvent) {
+                        result.handlers[event] = this.eventNameToHandler(controllerEvent);
+                        result.eventCount += 1;
+                    }
+                    return result;
+                }, { handlers: {}, eventCount: 0 });
+                // patch __ngt__ with events
+                applyProps(this.__ngt__, observedEvents);
+                // add as an interaction if there are events observed
+                if (observedEvents.eventCount > 0) {
+                    getInstanceLocalState(this.instanceValue)?.rootFactory().addInteraction(this.instanceValue);
+                }
+            }
+            return () => {
+                if (is.object3d(this.instanceValue) && this.__ngt__.eventCount > 0) {
+                    getInstanceLocalState(this.instanceValue)?.rootFactory().removeInteraction(this.instanceValue.uuid);
+                }
+            };
+        }));
+        this.attachToParent = this.effect(tap(() => {
+            const attach = this.read((s) => s.attach);
+            let parentInstanceRef = this.__ngt__?.parentRef;
+            // if no parentInstance, try re-run the factory due to late init
+            if (!parentInstanceRef || !parentInstanceRef.value) {
+                // return early if failed to retrieve
+                if (!this.parent?.value)
+                    return;
+                // reassign on instance internal state
+                if (this.__ngt__) {
+                    this.__ngt__.parentRef = this.parent;
+                }
+                parentInstanceRef = this.parent;
+            }
+            if (typeof attach === 'function') {
+                const attachCleanUp = attach(parentInstanceRef, this.instanceRef, this.store.read);
+                if (attachCleanUp) {
+                    this.__ngt__.attach = attachCleanUp;
+                }
+            }
+            else {
+                const propertyToAttach = [...attach];
+                // if propertyToAttach is empty
+                if (propertyToAttach.length === 0) {
+                    // this might be the case where we are attaching an object3D to the parent object3D
+                    if (is.object3d(this.instanceValue) &&
+                        is.object3d(this.proxyInstance) &&
+                        is.object3d(this.parent?.value)) {
+                        this.parent?.value.add(this.proxyInstance);
+                    }
+                }
+                else {
+                    // array material handling
+                    if (propertyToAttach[0] === 'material' &&
+                        propertyToAttach[1] &&
+                        typeof Number(propertyToAttach[1]) === 'number' &&
+                        is.material(this.instanceValue)) {
+                        if (!Array.isArray(parentInstanceRef.value.material)) {
+                            parentInstanceRef.value.material = [];
+                        }
+                    }
+                    // retrieve the current value on the parentInstance, so we can reset it later
+                    if (this.__ngt__) {
+                        this.__ngt__.attachValue = propertyToAttach.reduce((value, property) => value[property], parentInstanceRef.value);
+                    }
+                    // attach the instance value on the parent
+                    mutate(parentInstanceRef.value, this.proxyInstance, propertyToAttach);
+                }
+                // validate on the instance
+                invalidateInstance(this.instanceValue);
+                // validate on the parent
+                if (getInstanceLocalState(parentInstanceRef.value)) {
+                    invalidateInstance(parentInstanceRef.value);
+                }
+                // save the attach
+                if (this.__ngt__) {
+                    this.__ngt__.attach = propertyToAttach;
+                }
+                this.write({ attach: propertyToAttach });
+            }
+        }));
+    }
+    set ref(instance) {
+        this.write({ instanceRef: is.ref(instance) ? instance : new NgtRef(instance) });
+    }
+    set skipWrapper(skipWrapper) {
+        this.write({ skipWrapper });
+        this.write({ skipWrapperExplicit: true });
+    }
+    set skipInit(skipInit) {
+        this.write({ skipInit });
+        this.write({ skipInitExplicit: true });
+    }
+    set noAttach(noAttach) {
+        this.write({ noAttach });
+        this.write({ noAttachExplicit: true });
+    }
+    set attach(value) {
+        if (value) {
+            const attach = typeof value === 'function'
+                ? value
+                : Array.isArray(value)
+                    ? value.map((item) => (typeof item === 'number' ? item.toString() : item))
+                    : [value];
+            this.write({ attach, attachExplicit: true });
+        }
+    }
+    set isRaw(val) {
+        this._isRaw = val;
+    }
+    initialize() {
+        super.initialize();
+        this.write({
+            instanceRef: new NgtRef(null),
+            attach: [],
+            noAttach: false,
+            skipWrapper: false,
+            skipInit: false,
+        });
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => {
+            this.store.onReady(() => {
+                this.instanceReady(this.instanceRef.pipe(filter((instance) => !!instance)));
+            });
+        });
+    }
+    get instanceRef() {
+        return this.read((s) => s.instanceRef);
+    }
+    get instanceValue() {
+        if (!this.instanceRef.value)
+            return this.instanceRef.value;
+        return this._isRaw ? this.instanceRef.value?.valueOf() : this.instanceRef.value;
+    }
+    get proxyInstance() {
+        return this.instanceValue?.[NGT_PROXY_INSTANCE];
+    }
+    get __ngt__() {
+        return getInstanceLocalState(this._isRaw ? this.instanceRef.value : this.instanceValue);
+    }
+    get parent() {
+        return this.parentRef?.();
+    }
+    ngOnDestroy() {
+        this.zone.runOutsideAngular(() => {
+            this.destroy();
+        });
+        super.ngOnDestroy();
+    }
+    destroy() {
+        if (this.instanceValue) {
+            if (is.object3d(this.instanceValue)) {
+                const parentInstance = this.parent;
+                if (parentInstance && is.object3d(parentInstance.value)) {
+                    removeInteractivity(this.__ngt__.stateFactory.bind(this.__ngt__), this.instanceValue);
+                    parentInstance.value.remove(this.instanceValue);
+                    invalidateInstance(parentInstance.value);
+                }
+                if (this.instanceValue.clear != null) {
+                    this.instanceValue.clear();
+                }
+            }
+            else {
+                if (this.__ngt__) {
+                    // non-scene objects
+                    const previousAttach = this.__ngt__.attach;
+                    if (previousAttach != null) {
+                        if (typeof previousAttach === 'function') {
+                            previousAttach();
+                        }
+                        else {
+                            const previousAttachValue = this.__ngt__.attachValue;
+                            if (this.__ngt__.parentRef && this.__ngt__.parentRef.value) {
+                                mutate(this.__ngt__.parentRef.value, previousAttachValue, previousAttach);
+                            }
+                        }
+                        if (this.__ngt__.parentRef && this.__ngt__.parentRef.value) {
+                            invalidateInstance(this.__ngt__.parentRef.value);
+                        }
+                    }
+                }
+            }
+            const dispose = this.instanceValue['dispose'];
+            if (dispose && typeof dispose === 'function') {
+                dispose.apply(this.instanceValue);
+            }
+        }
+        this.write({ attach: [] });
+        this.instanceRef.complete();
+    }
+    eventNameToHandler(controllerEvent) {
+        return (event) => {
+            // go back into Angular Zone so that state updates on these events trigger CD
+            this.zone.run(() => {
+                controllerEvent.emit(event);
+            });
+        };
+    }
+}
+NgtInstance.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtInstance, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NgtInstance.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: NgtInstance, isStandalone: true, selector: "[ngtInstance]", inputs: { ref: "ref", skipWrapper: "skipWrapper", skipInit: "skipInit", noAttach: "noAttach", attach: "attach", priority: "priority", beforeRender: "beforeRender", readyCallback: "readyCallback", updateCallback: "updateCallback" }, outputs: { click: "click", contextmenu: "contextmenu", dblclick: "dblclick", pointerup: "pointerup", pointerdown: "pointerdown", pointerover: "pointerover", pointerout: "pointerout", pointerenter: "pointerenter", pointerleave: "pointerleave", pointermove: "pointermove", pointermissed: "pointermissed", pointercancel: "pointercancel", wheel: "wheel" }, exportAs: ["ngtInstance"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtInstance, decorators: [{
+            type: Directive,
             args: [{
-                    imports: [CommonModule],
+                    selector: '[ngtInstance]',
+                    exportAs: 'ngtInstance',
+                    standalone: true,
                 }]
+        }], propDecorators: { ref: [{
+                type: Input
+            }], skipWrapper: [{
+                type: Input
+            }], skipInit: [{
+                type: Input
+            }], noAttach: [{
+                type: Input
+            }], attach: [{
+                type: Input
+            }], priority: [{
+                type: Input
+            }], beforeRender: [{
+                type: Input
+            }], readyCallback: [{
+                type: Input
+            }], updateCallback: [{
+                type: Input
+            }], click: [{
+                type: Output
+            }], contextmenu: [{
+                type: Output
+            }], dblclick: [{
+                type: Output
+            }], pointerup: [{
+                type: Output
+            }], pointerdown: [{
+                type: Output
+            }], pointerover: [{
+                type: Output
+            }], pointerout: [{
+                type: Output
+            }], pointerenter: [{
+                type: Output
+            }], pointerleave: [{
+                type: Output
+            }], pointermove: [{
+                type: Output
+            }], pointermissed: [{
+                type: Output
+            }], pointercancel: [{
+                type: Output
+            }], wheel: [{
+                type: Output
+            }] } });
+const NGT_INSTANCE_INPUTS = [
+    'ref',
+    'attach',
+    'skipWrapper',
+    'skipInit',
+    'noAttach',
+    'beforeRender',
+    'priority',
+    'updateCallback',
+    'readyCallback',
+];
+const NGT_INSTANCE_OUTPUTS = [...supportedEvents];
+
+const defaultResizeOptions = {
+    box: 'content-box',
+    scroll: false,
+    offsetSize: false,
+    debounce: { scroll: 50, resize: 0 },
+};
+const [injectResizeOptions, provideResizeOptions] = createInjection('ngtResize Options', {
+    defaultValueOrFactory: defaultResizeOptions,
+    provideValueFactory: (value) => ({ ...defaultResizeOptions, ...value }),
+});
+const [injectResizeObserverSupport] = createInjection('Resize Observer API support', {
+    defaultValueOrFactory: () => {
+        const window = injectWindow();
+        return 'ResizeObserver' in window && window['ResizeObserver'] != null;
+    },
+});
+
+class NgtResize extends Observable {
+    constructor() {
+        const { nativeElement } = inject(ElementRef);
+        const zone = inject(NgZone);
+        const document = inject(DOCUMENT);
+        const window = injectWindow();
+        const isSupport = injectResizeObserverSupport();
+        const { box, offsetSize, scroll, debounce } = injectResizeOptions();
+        let observer;
+        let lastBounds;
+        let lastEntries = [];
+        const torndown$ = new Subject();
+        const scrollContainers = findScrollContainers(nativeElement, document.body);
+        // set actual debounce values early, so effects know if they should react accordingly
+        const scrollDebounce = debounce ? (typeof debounce === 'number' ? debounce : debounce.scroll) : null;
+        const resizeDebounce = debounce ? (typeof debounce === 'number' ? debounce : debounce.resize) : null;
+        const debounceAndDestroy = (debounce) => {
+            return pipe(debounceTime(debounce ?? 0), takeUntil(torndown$));
+        };
+        super((subscriber) => {
+            if (!isSupport) {
+                subscriber.error('ResizeObserver is not supported in your browser. Please use a polyfill');
+                return;
+            }
+            zone.runOutsideAngular(() => {
+                const callback = (entries) => {
+                    lastEntries = entries;
+                    const { left, top, width, height, bottom, right, x, y } = nativeElement.getBoundingClientRect();
+                    const size = {
+                        left,
+                        top,
+                        width,
+                        height,
+                        bottom,
+                        right,
+                        x,
+                        y,
+                    };
+                    if (nativeElement instanceof HTMLElement && offsetSize) {
+                        size.height = nativeElement.offsetHeight;
+                        size.width = nativeElement.offsetWidth;
+                    }
+                    Object.freeze(size);
+                    subscriber.next({
+                        entries,
+                        dpr: window.devicePixelRatio,
+                        ...size,
+                    });
+                    if (!areBoundsEqual(lastBounds || {}, size)) {
+                        lastBounds = size;
+                    }
+                };
+                const boundEntriesCallback = () => {
+                    callback(lastEntries);
+                };
+                observer = new ResizeObserver(callback);
+                observer.observe(nativeElement, { box });
+                if (scroll) {
+                    if (scrollContainers) {
+                        scrollContainers.forEach((scrollContainer) => {
+                            fromEvent(scrollContainer, 'scroll', {
+                                capture: true,
+                                passive: true,
+                            })
+                                .pipe(debounceAndDestroy(scrollDebounce))
+                                .subscribe(boundEntriesCallback);
+                        });
+                    }
+                    fromEvent(window, 'scroll', {
+                        capture: true,
+                        passive: true,
+                    })
+                        .pipe(debounceAndDestroy(scrollDebounce))
+                        .subscribe(boundEntriesCallback);
+                }
+                fromEvent(window, 'resize').pipe(debounceAndDestroy(resizeDebounce)).subscribe(boundEntriesCallback);
+            });
+            return () => {
+                if (observer) {
+                    observer.unobserve(nativeElement);
+                    observer.disconnect();
+                }
+                torndown$.next();
+                torndown$.complete();
+            };
+        });
+        return this.pipe(debounceTime(scrollDebounce || 0), share({
+            connector: () => new ReplaySubject(1),
+            resetOnRefCountZero: true,
+            resetOnComplete: true,
+        }));
+    }
+}
+NgtResize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtResize, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgtResize.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtResize });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtResize, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+// Returns a list of scroll offsets
+function findScrollContainers(element, documentBody) {
+    const result = [];
+    if (!element || element === documentBody)
+        return result;
+    const { overflow, overflowX, overflowY } = window.getComputedStyle(element);
+    if ([overflow, overflowX, overflowY].some((prop) => prop === 'auto' || prop === 'scroll'))
+        result.push(element);
+    return [...result, ...findScrollContainers(element.parentElement, documentBody)];
+}
+// Checks if element boundaries are equal
+const keys = [
+    'x',
+    'y',
+    'top',
+    'bottom',
+    'left',
+    'right',
+    'width',
+    'height',
+];
+const areBoundsEqual = (a, b) => keys.every((key) => a[key] === b[key]);
+
+function buildGraph(object) {
+    const data = { nodes: {}, materials: {} };
+    if (object) {
+        object.traverse((obj) => {
+            if (obj.name)
+                data.nodes[obj.name] = obj;
+            if ('material' in obj && !data.materials[obj.material.name]) {
+                data.materials[obj.material.name] = obj
+                    .material;
+            }
+        });
+    }
+    return data;
+}
+
+class NgtLoader {
+    constructor() {
+        this.cached = new Map();
+    }
+    use(loadConstructor, input, extensions, onProgress) {
+        const urls = Array.isArray(input) ? input : [input];
+        const loader = new loadConstructor();
+        if (extensions) {
+            extensions(loader);
+        }
+        const observables$ = urls.map((url) => {
+            if (!this.cached.has(url)) {
+                this.cached.set(url, from(loader.loadAsync(url, onProgress)).pipe(tap((data) => {
+                    if (data.scene) {
+                        Object.assign(data, buildGraph(data.scene));
+                    }
+                }), retry(2), catchError((err) => {
+                    console.error(`[NgtLoader]: Error loading ${url}: ${err.message}`);
+                    return of(null);
+                }), share({
+                    connector: () => new ReplaySubject(1),
+                    resetOnComplete: true,
+                    resetOnRefCountZero: true,
+                    resetOnError: true,
+                })));
+            }
+            return this.cached.get(url);
+        });
+        return forkJoin(observables$).pipe(map((results) => (Array.isArray(input) ? results : results[0])));
+    }
+    destroy() {
+        this.cached.clear();
+    }
+}
+NgtLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+NgtLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtLoader, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }] });
 
+class NgtCanvasContainer {
+    constructor() {
+        this.resize = inject(NgtResize);
+    }
+}
+NgtCanvasContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvasContainer, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtCanvasContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", type: NgtCanvasContainer, isStandalone: true, selector: "ngt-canvas-container", outputs: { resize: "resize" }, providers: [NgtResize], ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: [":host{display:block;height:100%;width:100%}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvasContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngt-canvas-container', standalone: true, template: '<ng-content></ng-content>', providers: [NgtResize], styles: [":host{display:block;height:100%;width:100%}\n"] }]
+        }], propDecorators: { resize: [{
+                type: Output
+            }] } });
+class NgtCanvas extends NgtComponentStore {
+    constructor() {
+        super(...arguments);
+        this.hostClass = true;
+        this.created = new EventEmitter();
+        this.canvasPointerMissed = new EventEmitter();
+        this.zone = inject(NgZone);
+        this.loader = inject(NgtLoader);
+        this.store = inject(NgtStore, { self: true });
+        this.host = inject(ElementRef);
+    }
+    get pointerEvents() {
+        return this.read((s) => s.eventSource) !== this.host.nativeElement ? 'none' : 'auto';
+    }
+    set linear(linear) {
+        this.write({ linear });
+    }
+    set legacy(legacy) {
+        this.write({ legacy });
+    }
+    set flat(flat) {
+        this.write({ flat });
+    }
+    set orthographic(orthographic) {
+        this.write({ orthographic });
+    }
+    set frameloop(frameloop) {
+        this.write({ frameloop });
+    }
+    set dpr(dpr) {
+        this.write({ dpr });
+    }
+    set raycaster(raycaster) {
+        this.write({ raycaster });
+    }
+    set shadows(shadows) {
+        this.write({
+            shadows: typeof shadows === 'object' ? shadows : shadows,
+        });
+    }
+    set camera(camera) {
+        this.write({ camera });
+    }
+    set gl(gl) {
+        this.write({ gl });
+    }
+    set eventSource(eventSource) {
+        this.write({ eventSource });
+    }
+    set eventPrefix(eventPrefix) {
+        this.write({ eventPrefix });
+    }
+    set lookAt(lookAt) {
+        this.write({ lookAt });
+    }
+    set performance(performance) {
+        this.write({ performance });
+    }
+    get sceneRef() {
+        return this.store.read((s) => s.sceneRef);
+    }
+    get isConfigured() {
+        return this.store.isConfigured;
+    }
+    initialize() {
+        super.initialize();
+        this.write({
+            shadows: false,
+            linear: false,
+            flat: false,
+            legacy: false,
+            orthographic: false,
+            frameloop: 'always',
+            dpr: [1, 2],
+            events: createPointerEvents,
+        });
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => {
+            if (!this.eventSource) {
+                this.eventSource = this.host.nativeElement;
+            }
+            if (this.canvasPointerMissed.observed) {
+                // update pointerMissed event
+                this.store.write({
+                    onPointerMissed: (event) => {
+                        // go back into angular zone
+                        this.zone.run(() => {
+                            this.canvasPointerMissed.emit(event);
+                        });
+                    },
+                });
+            }
+            // set rootStateMap
+            rootStateMap.set(this.glCanvas.nativeElement, this.store.read);
+            // setup canvas state
+            this.store.init();
+            this.store.onReady(() => {
+                const state = this.store.read();
+                const inputs = this.read();
+                // canvas is ready
+                this.store.write((s) => ({ internal: { ...s.internal, active: true } }));
+                // Connect to eventsource
+                state.events.connect?.(inputs.eventSource instanceof ElementRef ? inputs.eventSource.nativeElement : inputs.eventSource);
+                // Set up compute function
+                if (inputs.eventPrefix) {
+                    state.setEvents({
+                        compute: (event, stateGetter) => {
+                            const innerState = stateGetter();
+                            const x = event[(inputs.eventPrefix + 'X')];
+                            const y = event[(inputs.eventPrefix + 'Y')];
+                            innerState.pointer.set((x / innerState.size.width) * 2 - 1, -(y / innerState.size.height) * 2 + 1);
+                            innerState.raycaster.setFromCamera(innerState.pointer, innerState.camera);
+                        },
+                    });
+                }
+                if (this.created.observed) {
+                    this.zone.run(() => {
+                        this.created.emit(this.store.read());
+                    });
+                }
+            });
+        });
+    }
+    onResize(resizeResult) {
+        this.zone.runOutsideAngular(() => {
+            const { width, height } = resizeResult;
+            if (width > 0 && height > 0) {
+                if (!this.store.isInit) {
+                    this.store.init();
+                }
+                this.store.configure(this.read(), this.glCanvas.nativeElement);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.loader.destroy();
+        super.ngOnDestroy();
+    }
+}
+NgtCanvas.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvas, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtCanvas.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", type: NgtCanvas, isStandalone: true, selector: "ngt-canvas", inputs: { linear: "linear", legacy: "legacy", flat: "flat", orthographic: "orthographic", frameloop: "frameloop", dpr: "dpr", raycaster: "raycaster", shadows: "shadows", camera: "camera", gl: "gl", eventSource: "eventSource", eventPrefix: "eventPrefix", lookAt: "lookAt", performance: "performance" }, outputs: { created: "created", canvasPointerMissed: "canvasPointerMissed" }, host: { properties: { "class.ngt-canvas": "this.hostClass", "style.pointerEvents": "this.pointerEvents" } }, providers: [NgtStore, provideInstanceRef(NgtCanvas, (canvas) => canvas.sceneRef)], queries: [{ propertyName: "canvasContent", first: true, predicate: TemplateRef, descendants: true, static: true }], viewQueries: [{ propertyName: "glCanvas", first: true, predicate: ["glCanvas"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-canvas-container (resize)="onResize($event)">
+            <canvas #glCanvas style="display: block">
+                <ng-container *ngIf="isConfigured" [ngTemplateOutlet]="canvasContent"></ng-container>
+                <ng-content></ng-content>
+            </canvas>
+        </ngt-canvas-container>
+    `, isInline: true, styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden}\n"], dependencies: [{ kind: "component", type: NgtCanvasContainer, selector: "ngt-canvas-container", outputs: ["resize"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtCanvas, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngt-canvas', standalone: true, template: `
+        <ngt-canvas-container (resize)="onResize($event)">
+            <canvas #glCanvas style="display: block">
+                <ng-container *ngIf="isConfigured" [ngTemplateOutlet]="canvasContent"></ng-container>
+                <ng-content></ng-content>
+            </canvas>
+        </ngt-canvas-container>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, imports: [NgtCanvasContainer, NgIf, NgTemplateOutlet, AsyncPipe], providers: [NgtStore, provideInstanceRef(NgtCanvas, (canvas) => canvas.sceneRef)], styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden}\n"] }]
+        }], propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class.ngt-canvas']
+            }], pointerEvents: [{
+                type: HostBinding,
+                args: ['style.pointerEvents']
+            }], linear: [{
+                type: Input
+            }], legacy: [{
+                type: Input
+            }], flat: [{
+                type: Input
+            }], orthographic: [{
+                type: Input
+            }], frameloop: [{
+                type: Input
+            }], dpr: [{
+                type: Input
+            }], raycaster: [{
+                type: Input
+            }], shadows: [{
+                type: Input
+            }], camera: [{
+                type: Input
+            }], gl: [{
+                type: Input
+            }], eventSource: [{
+                type: Input
+            }], eventPrefix: [{
+                type: Input
+            }], lookAt: [{
+                type: Input
+            }], performance: [{
+                type: Input
+            }], created: [{
+                type: Output
+            }], canvasPointerMissed: [{
+                type: Output
+            }], glCanvas: [{
+                type: ViewChild,
+                args: ['glCanvas', { static: true }]
+            }], canvasContent: [{
+                type: ContentChild,
+                args: [TemplateRef, { static: true }]
+            }] } });
+
+const NGT_ARGS = new InjectionToken('NgtArgs');
+function injectArgs(options = {}) {
+    return inject(NGT_ARGS, options);
+}
+class NgtArgs {
+    constructor() {
+        this.templateRef = inject(TemplateRef);
+        this.vcr = inject(ViewContainerRef);
+    }
+    set args(args) {
+        if (this.view) {
+            this.view.destroy();
+        }
+        this.view = this.vcr.createEmbeddedView(this.templateRef, {}, { injector: Injector.create({ providers: [{ provide: NGT_ARGS, useValue: args }] }) });
+    }
+}
+NgtArgs.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtArgs, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+NgtArgs.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.0", type: NgtArgs, isStandalone: true, selector: "[args]", inputs: { args: "args" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtArgs, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[args]',
+                    standalone: true,
+                }]
+        }], propDecorators: { args: [{
+                type: Input
+            }] } });
+
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function proxify(instance, proxifyOptions = {}) {
+    const ngtInstance = injectInstance({ host: true });
+    const store = inject(NgtStore);
+    const zone = inject(NgZone);
+    const parentInstance = injectInstanceRef({ skipSelf: true, optional: true });
+    return zone.runOutsideAngular(() => {
+        // prep the instance w/ local state
+        instance = prepare(instance, store.read, store.rootStateFactory, parentInstance?.(), ngtInstance.instanceValue ? ngtInstance.instanceRef : undefined, !!proxifyOptions.primitive);
+        let storeReadySubscription;
+        const newValueSubscriptionMap = new Map();
+        function setProp(obj, prop, newValue) {
+            const capitalizedProp = `set${capitalize(prop)}`;
+            if (isObservable(newValue)) {
+                const sub = newValue.subscribe((val) => {
+                    if (obj[capitalizedProp] && typeof obj[capitalizedProp] === 'function') {
+                        obj[capitalizedProp](val);
+                    }
+                    else {
+                        applyProps(obj, { [prop]: val });
+                    }
+                    ngtInstance.write({ [prop]: val });
+                });
+                return () => sub.unsubscribe();
+            }
+            if (obj[capitalizedProp] && typeof obj[capitalizedProp] === 'function') {
+                obj[capitalizedProp](newValue);
+            }
+            else {
+                applyProps(obj, { [prop]: newValue });
+            }
+            ngtInstance.write({ [prop]: newValue });
+            return;
+        }
+        const handler = {
+            get(target, p, receiver) {
+                if (p === 'instanceRef')
+                    return ngtInstance.instanceRef;
+                if (p === 'instance')
+                    return ngtInstance;
+                if (p === NGT_PROXY_INSTANCE)
+                    return target;
+                const capitalizedProp = `get${capitalize(p)}`;
+                if (target[capitalizedProp] && typeof target[capitalizedProp] === 'function') {
+                    return target[capitalizedProp]();
+                }
+                return Reflect.get(target, p, receiver);
+            },
+            set(target, p, newValue, receiver) {
+                const prop = p;
+                if (storeReadySubscription)
+                    storeReadySubscription.unsubscribe();
+                if (newValueSubscriptionMap.has(prop))
+                    newValueSubscriptionMap.get(prop)();
+                // Angular sets this property
+                if (p === '__ngContext__')
+                    return Reflect.set(target, p, newValue, receiver);
+                return zone.runOutsideAngular(() => {
+                    // TODO: figure out what else we need to handle
+                    // we should handle if newValue is an Observable as well
+                    if (store.read((s) => s.ready)) {
+                        const cleanUp = setProp(instance, prop, newValue);
+                        if (cleanUp)
+                            newValueSubscriptionMap.set(prop, cleanUp);
+                    }
+                    else {
+                        storeReadySubscription = store.onReady(() => setProp(instance, prop, newValue));
+                    }
+                    // schedule updateCallback on next event loop
+                    queueMicrotask(() => {
+                        if (ngtInstance.updateCallback)
+                            ngtInstance.updateCallback(instance);
+                    });
+                    return true;
+                });
+            },
+        };
+        ngtInstance.effect(tapEffect(() => () => {
+            if (storeReadySubscription)
+                storeReadySubscription.unsubscribe();
+            newValueSubscriptionMap.forEach((cleanUp) => cleanUp());
+        }))();
+        const proxied = new Proxy(instance, handler);
+        if (proxifyOptions.attach)
+            ngtInstance.attach = proxifyOptions.attach;
+        if (proxifyOptions.created)
+            proxifyOptions.created(proxied, store.read, ngtInstance);
+        ngtInstance.instanceRef.set(proxied);
+        return proxied;
+    });
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AngularThreeModule };
+export { NGT_ARGS, NGT_INSTANCE_INPUTS, NGT_INSTANCE_OUTPUTS, NGT_INSTANCE_REF_FACTORY, NGT_PROXY_INSTANCE, NgtArgs, NgtCanvas, NgtCanvasContainer, NgtComponentStore, NgtInstance, NgtLoader, NgtResize, NgtStore, addAfterEffect, addEffect, addTail, createLoop, defaultProjector, defaultResizeOptions, flushGlobalEffects, injectArgs, injectInstance, injectInstanceRef, injectResizeObserverSupport, injectResizeOptions, provideInstanceRef, provideResizeOptions, proxify, rootStateMap, skipFirstUndefined, tapEffect };
 //# sourceMappingURL=angular-three.mjs.map