@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Sprites/spriteMap.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Class used to manage a grid restricted sprite deployment on an Output plane.
+ */
+export class SpriteMap {
+    /**
+     * Creates a new SpriteMap
+     * @param name defines the SpriteMaps Name
+     * @param atlasJSON is the JSON file that controls the Sprites Frames and Meta
+     * @param spriteSheet is the Texture that the Sprites are on.
+     * @param options a basic deployment configuration
+     * @param scene The Scene that the map is deployed on
+     */
+    constructor(name: any, atlasJSON: any, spriteSheet: any, options: any, scene: any);
+    name: any;
+    sprites: any;
+    atlasJSON: any;
+    spriteSheet: any;
+    /**
+     * Run through the options and set what ever defaults are needed that where not declared.
+     */
+    options: any;
+    _scene: any;
+    _frameMap: RawTexture;
+    _tileMaps: any[];
+    _animationMap: RawTexture;
+    _material: ShaderMaterial;
+    _time: number;
+    _output: import("@babylonjs/core").Mesh;
+    /** Returns the Position of Output Plane*/
+    set position(arg: Vector3);
+    /** Returns the Position of Output Plane*/
+    get position(): Vector3;
+    /** Returns the Rotation of Output Plane*/
+    set rotation(arg: Vector3);
+    /** Returns the Rotation of Output Plane*/
+    get rotation(): Vector3;
+    /** Returns the Number of Sprites in the System */
+    get spriteCount(): any;
+    /** Sets the AnimationMap*/
+    set animationMap(arg: RawTexture);
+    /** Sets the AnimationMap*/
+    get animationMap(): RawTexture;
+    /**
+     * Returns tileID location
+     * @returns Vector2 the cell position ID
+     */
+    getTileID(): any;
+    /**
+     * Gets the UV location of the mouse over the SpriteMap.
+     * @returns Vector2 the UV position of the mouse interaction
+     */
+    getMousePosition(): any;
+    /**
+     * Creates the "frame" texture Buffer
+     * -------------------------------------
+     * Structure of frames
+     *  "filename": "Falling-Water-2.png",
+     * "frame": {"x":69,"y":103,"w":24,"h":32},
+     * "rotated": true,
+     * "trimmed": true,
+     * "spriteSourceSize": {"x":4,"y":0,"w":24,"h":32},
+     * "sourceSize": {"w":32,"h":32}
+     * @returns RawTexture of the frameMap
+     */
+    _createFrameBuffer(): RawTexture;
+    /**
+     * Creates the tileMap texture Buffer
+     * @param buffer normally and array of numbers, or a false to generate from scratch
+     * @param _layer indicates what layer for a logic trigger dealing with the baseTile.  The system uses this
+     * @returns RawTexture of the tileMap
+     */
+    _createTileBuffer(buffer: any, _layer?: number): RawTexture;
+    /**
+     * Modifies the data of the tileMaps
+     * @param _layer is the ID of the layer you want to edit on the SpriteMap
+     * @param pos is the iVector2 Coordinates of the Tile
+     * @param tile The SpriteIndex of the new Tile
+     */
+    changeTiles(_layer: number | undefined, pos: any, tile?: number): void;
+    /**
+     * Creates the animationMap texture Buffer
+     * @param buffer normally and array of numbers, or a false to generate from scratch
+     * @returns RawTexture of the animationMap
+     */
+    _createTileAnimationBuffer(buffer: any): RawTexture;
+    /**
+     * Modifies the data of the animationMap
+     * @param cellID is the Index of the Sprite
+     * @param _frame is the target Animation frame
+     * @param toCell is the Target Index of the next frame of the animation
+     * @param time is a value between 0-1 that is the trigger for when the frame should change tiles
+     * @param speed is a global scalar of the time variable on the map.
+     */
+    addAnimationToTile(cellID?: number, _frame?: number, toCell?: number, time?: number, speed?: number): void;
+    /**
+     * Exports the .tilemaps file
+     */
+    saveTileMaps(): void;
+    /**
+     * Imports the .tilemaps file
+     * @param url of the .tilemaps file
+     */
+    loadTileMaps(url: any): void;
+    /**
+     * Release associated resources
+     */
+    dispose(): void;
+}
+import { RawTexture } from "../Materials/Textures/rawTexture.js";
+import { ShaderMaterial } from "../Materials/shaderMaterial.js";
+import { Vector3 } from "../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Sprites/spritePackedManager.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Class used to manage multiple sprites of different sizes on the same spritesheet
+ * @see https://doc.babylonjs.com/babylon101/sprites
+ */
+export class SpritePackedManager extends SpriteManager {
+    /**
+     * Creates a new sprite manager from a packed sprite sheet
+     * @param name defines the manager's name
+     * @param imgUrl defines the sprite sheet url
+     * @param capacity defines the maximum allowed number of sprites
+     * @param scene defines the hosting scene
+     * @param spriteJSON null otherwise a JSON object defining sprite sheet data
+     * @param epsilon defines the epsilon value to align texture (0.01 by default)
+     * @param samplingMode defines the sampling mode to use with spritesheet
+     * @param fromPacked set to true; do not alter
+     */
+    constructor(name: any, imgUrl: any, capacity: any, scene: any, spriteJSON?: null, epsilon?: number, samplingMode?: number);
+    name: any;
+}
+import { SpriteManager } from "./spriteManager.js";

package/dist/types/node_modules/@babylonjs/core/Sprites/spriteRenderer.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Class used to render sprites.
+ *
+ * It can be used either to render Sprites or ThinSprites with ThinEngine only.
+ */
+export class SpriteRenderer {
+    /**
+     * Creates a new sprite Renderer
+     * @param engine defines the engine the renderer works with
+     * @param capacity defines the maximum allowed number of sprites
+     * @param epsilon defines the epsilon value to align texture (0.01 by default)
+     * @param scene defines the hosting scene
+     */
+    constructor(engine: any, capacity: any, epsilon?: number, scene?: null);
+    /**
+     * Blend mode use to render the particle, it can be any of
+     * the static undefined properties provided in this class.
+     * Default value is 2
+     */
+    blendMode: number;
+    /**
+     * Gets or sets a boolean indicating if alpha mode is automatically
+     * reset.
+     */
+    autoResetAlpha: boolean;
+    /**
+     * Disables writing to the depth buffer when rendering the sprites.
+     * It can be handy to disable depth writing when using textures without alpha channel
+     * and setting some specific blend modes.
+     */
+    disableDepthWrite: boolean;
+    /**
+     * Gets or sets a boolean indicating if the manager must consider scene fog when rendering
+     */
+    fogEnabled: boolean;
+    _useVAO: any;
+    _useInstancing: any;
+    _vertexBuffers: {};
+    _capacity: any;
+    _epsilon: number;
+    _engine: any;
+    _scene: any;
+    _drawWrapperBase: DrawWrapper;
+    _drawWrapperFog: DrawWrapper;
+    _drawWrapperDepth: DrawWrapper;
+    _drawWrapperFogDepth: DrawWrapper;
+    _vertexBufferSize: number;
+    _vertexData: Float32Array;
+    _buffer: Buffer;
+    _spriteBuffer: Buffer | undefined;
+    /**
+     * Gets the capacity of the manager
+     */
+    get capacity(): any;
+    /**
+     * Render all child sprites
+     * @param sprites defines the list of sprites to render
+     * @param deltaTime defines the time since last frame
+     * @param viewMatrix defines the viewMatrix to use to render the sprites
+     * @param projectionMatrix defines the projectionMatrix to use to render the sprites
+     * @param customSpriteUpdate defines a custom function to update the sprites data before they render
+     */
+    render(sprites: any, deltaTime: any, viewMatrix: any, projectionMatrix: any, customSpriteUpdate?: null): void;
+    _vertexArrayObject: any;
+    _appendSpriteVertex(index: any, sprite: any, offsetX: any, offsetY: any, baseSize: any, useRightHandedSystem: any, customSpriteUpdate: any): void;
+    _buildIndexBuffer(): void;
+    _indexBuffer: any;
+    /**
+     * Rebuilds the renderer (after a context lost, for eg)
+     */
+    rebuild(): void;
+    /**
+     * Release associated resources
+     */
+    dispose(): void;
+    texture: any;
+}
+import { DrawWrapper } from "../Materials/drawWrapper.js";
+import { Buffer } from "../Buffers/buffer.js";

package/dist/types/node_modules/@babylonjs/core/Sprites/spriteSceneComponent.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Defines the sprite scene component responsible to manage sprites
+ * in a given scene.
+ */
+export class SpriteSceneComponent {
+    /**
+     * Creates a new instance of the component for the given scene
+     * @param scene Defines the scene to register the component in
+     */
+    constructor(scene: any);
+    /**
+     * The component name helpfull to identify the component in the list of scene components.
+     */
+    name: string;
+    scene: any;
+    _spritePredicate: (sprite: any) => any;
+    /**
+     * Registers the component in a given scene
+     */
+    register(): void;
+    /**
+     * Rebuilds the elements related to this component in case of
+     * context lost for instance.
+     */
+    rebuild(): void;
+    /**
+     * Disposes the component and the associated resources.
+     */
+    dispose(): void;
+    _pickSpriteButKeepRay(originalPointerInfo: any, x: any, y: any, fastCheck: any, camera: any): any;
+    _pointerMove(unTranslatedPointerX: any, unTranslatedPointerY: any, pickResult: any, isMeshPicked: any, element: any): any;
+    _pointerDown(unTranslatedPointerX: any, unTranslatedPointerY: any, pickResult: any, evt: any): any;
+    _pointerUp(unTranslatedPointerX: any, unTranslatedPointerY: any, pickResult: any, evt: any, doubleClick: any): any;
+}

package/dist/types/node_modules/@babylonjs/core/Sprites/thinSprite.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ThinSprite Class used to represent a thin sprite
+ * This is the base class for sprites but can also directly be used with ThinEngine
+ * @see https://doc.babylonjs.com/babylon101/sprites
+ */
+export class ThinSprite {
+    /** Gets or sets the width */
+    width: number;
+    /** Gets or sets the height */
+    height: number;
+    /** Gets or sets rotation angle */
+    angle: number;
+    /** Gets or sets a boolean indicating if UV coordinates should be inverted in U axis */
+    invertU: boolean;
+    /** Gets or sets a boolean indicating if UV coordinates should be inverted in B axis */
+    invertV: boolean;
+    /** Gets or sets a boolean indicating if the sprite is visible (renderable). Default is true */
+    isVisible: boolean;
+    _animationStarted: boolean;
+    _loopAnimation: boolean;
+    _fromIndex: number;
+    _toIndex: number;
+    _delay: number;
+    _direction: number;
+    _time: number;
+    _onBaseAnimationEnd: any;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /**
+     * Returns a boolean indicating if the animation is started
+     */
+    get animationStarted(): boolean;
+    /** Gets the initial key for the animation (setting it will restart the animation)  */
+    get fromIndex(): number;
+    /** Gets or sets the end key for the animation (setting it will restart the animation)  */
+    get toIndex(): number;
+    /** Gets or sets a boolean indicating if the animation is looping (setting it will restart the animation)  */
+    get loopAnimation(): boolean;
+    /** Gets or sets the delay between cell changes (setting it will restart the animation)  */
+    get delay(): number;
+    /**
+     * Starts an animation
+     * @param from defines the initial key
+     * @param to defines the end key
+     * @param loop defines if the animation must loop
+     * @param delay defines the start delay (in ms)
+     * @param onAnimationEnd defines a callback for when the animation ends
+     */
+    playAnimation(from: any, to: any, loop: any, delay: any, onAnimationEnd: any): void;
+    cellIndex: any;
+    /** Stops current animation (if any) */
+    stopAnimation(): void;
+    /**
+     * @internal
+     */
+    _animate(deltaTime: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/States/IStencilState.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/node_modules/@babylonjs/core/States/alphaCullingState.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @internal
+ **/
+export class AlphaState {
+    _blendFunctionParameters: any[];
+    _blendEquationParameters: any[];
+    _blendConstants: any[];
+    _isBlendConstantsDirty: boolean;
+    _alphaBlend: boolean;
+    _isAlphaBlendDirty: boolean;
+    _isBlendFunctionParametersDirty: boolean;
+    _isBlendEquationParametersDirty: boolean;
+    get isDirty(): boolean;
+    set alphaBlend(arg: boolean);
+    get alphaBlend(): boolean;
+    setAlphaBlendConstants(r: any, g: any, b: any, a: any): void;
+    setAlphaBlendFunctionParameters(value0: any, value1: any, value2: any, value3: any): void;
+    setAlphaEquationParameters(rgb: any, alpha: any): void;
+    reset(): void;
+    apply(gl: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/States/depthCullingState.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @internal
+ **/
+export class DepthCullingState {
+    /**
+     * Initializes the state.
+     * @param reset
+     */
+    constructor(reset?: boolean);
+    _isDepthTestDirty: boolean;
+    _isDepthMaskDirty: boolean;
+    _isDepthFuncDirty: boolean;
+    _isCullFaceDirty: boolean;
+    _isCullDirty: boolean;
+    _isZOffsetDirty: boolean;
+    _isFrontFaceDirty: boolean;
+    get isDirty(): boolean;
+    set zOffset(arg: any);
+    get zOffset(): any;
+    _zOffset: any;
+    set zOffsetUnits(arg: any);
+    get zOffsetUnits(): any;
+    _zOffsetUnits: any;
+    set cullFace(arg: any);
+    get cullFace(): any;
+    _cullFace: any;
+    set cull(arg: any);
+    get cull(): any;
+    _cull: any;
+    set depthFunc(arg: any);
+    get depthFunc(): any;
+    _depthFunc: any;
+    set depthMask(arg: any);
+    get depthMask(): any;
+    _depthMask: any;
+    set depthTest(arg: any);
+    get depthTest(): any;
+    _depthTest: any;
+    set frontFace(arg: any);
+    get frontFace(): any;
+    _frontFace: any;
+    reset(): void;
+    apply(gl: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/States/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./alphaCullingState.js";
+export * from "./depthCullingState.js";
+export * from "./stencilState.js";
+export * from "./stencilStateComposer.js";

package/dist/types/node_modules/@babylonjs/core/States/stencilState.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @internal
+ **/
+export class StencilState {
+    reset(): void;
+    enabled: any;
+    mask: any;
+    func: any;
+    funcRef: any;
+    funcMask: any;
+    opStencilFail: any;
+    opDepthFail: any;
+    opStencilDepthPass: any;
+    set stencilFunc(arg: any);
+    get stencilFunc(): any;
+    set stencilFuncRef(arg: any);
+    get stencilFuncRef(): any;
+    set stencilFuncMask(arg: any);
+    get stencilFuncMask(): any;
+    set stencilOpStencilFail(arg: any);
+    get stencilOpStencilFail(): any;
+    set stencilOpDepthFail(arg: any);
+    get stencilOpDepthFail(): any;
+    set stencilOpStencilDepthPass(arg: any);
+    get stencilOpStencilDepthPass(): any;
+    set stencilMask(arg: any);
+    get stencilMask(): any;
+    set stencilTest(arg: any);
+    get stencilTest(): any;
+}
+export namespace StencilState {
+    const ALWAYS: number;
+    const KEEP: number;
+    const REPLACE: number;
+}

package/dist/types/node_modules/@babylonjs/core/States/stencilStateComposer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @internal
+ **/
+export class StencilStateComposer {
+    constructor(reset?: boolean);
+    _isStencilTestDirty: boolean;
+    _isStencilMaskDirty: boolean;
+    _isStencilFuncDirty: boolean;
+    _isStencilOpDirty: boolean;
+    useStencilGlobalOnly: boolean;
+    get isDirty(): boolean;
+    set func(arg: any);
+    get func(): any;
+    _func: any;
+    set funcRef(arg: any);
+    get funcRef(): any;
+    _funcRef: any;
+    set funcMask(arg: any);
+    get funcMask(): any;
+    _funcMask: any;
+    set opStencilFail(arg: any);
+    get opStencilFail(): any;
+    _opStencilFail: any;
+    set opDepthFail(arg: any);
+    get opDepthFail(): any;
+    _opDepthFail: any;
+    set opStencilDepthPass(arg: any);
+    get opStencilDepthPass(): any;
+    _opStencilDepthPass: any;
+    set mask(arg: any);
+    get mask(): any;
+    _mask: any;
+    set enabled(arg: any);
+    get enabled(): any;
+    _enabled: any;
+    reset(): void;
+    stencilMaterial: any;
+    apply(gl: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/XR/features/WebXRAbstractFeature.d.ts

@@ -0,0 +1,61 @@
+/**
+ * This is the base class for all WebXR features.
+ * Since most features require almost the same resources and callbacks, this class can be used to simplify the development
+ * Note that since the features manager is using the `IWebXRFeature` you are in no way obligated to use this class
+ */
+export class WebXRAbstractFeature {
+    /**
+     * Construct a new (abstract) WebXR feature
+     * @param _xrSessionManager the xr session manager for this feature
+     */
+    constructor(_xrSessionManager: any);
+    _xrSessionManager: any;
+    _attached: boolean;
+    _removeOnDetach: any[];
+    /**
+     * Is this feature disposed?
+     */
+    isDisposed: boolean;
+    /**
+     * Should auto-attach be disabled?
+     */
+    disableAutoAttach: boolean;
+    /**
+     * The name of the native xr feature name (like anchor, hit-test, or hand-tracking)
+     */
+    xrNativeFeatureName: string;
+    /**
+     * Is this feature attached
+     */
+    get attached(): boolean;
+    /**
+     * attach this feature
+     *
+     * @param force should attachment be forced (even when already attached)
+     * @returns true if successful, false is failed or already attached
+     */
+    attach(force: any): boolean;
+    /**
+     * detach this feature.
+     *
+     * @returns true if successful, false if failed or already detached
+     */
+    detach(): boolean;
+    /**
+     * Dispose this feature and all of the resources attached
+     */
+    dispose(): void;
+    /**
+     * This function will be executed during before enabling the feature and can be used to not-allow enabling it.
+     * Note that at this point the session has NOT started, so this is purely checking if the browser supports it
+     *
+     * @returns whether or not the feature is compatible in this environment
+     */
+    isCompatible(): boolean;
+    /**
+     * This is used to register callbacks that will automatically be removed when detach is called.
+     * @param observable the observable to which the observer will be attached
+     * @param callback the callback to register
+     */
+    _addNewAttachObserver(observable: any, callback: any): void;
+}

package/dist/types/node_modules/@babylonjs/core/XR/features/WebXRAnchorSystem.d.ts

@@ -0,0 +1,85 @@
+/**
+ * An implementation of the anchor system for WebXR.
+ * For further information see https://github.com/immersive-web/anchors/
+ */
+export class WebXRAnchorSystem extends WebXRAbstractFeature {
+    /**
+     * constructs a new anchor system
+     * @param _xrSessionManager an instance of WebXRSessionManager
+     * @param _options configuration object for this feature
+     */
+    constructor(_xrSessionManager: any, _options?: {});
+    _options: {};
+    _lastFrameDetected: Set<any>;
+    _trackedAnchors: any[];
+    _futureAnchors: any[];
+    /**
+     * Observers registered here will be executed when a new anchor was added to the session
+     */
+    onAnchorAddedObservable: Observable<any>;
+    /**
+     * Observers registered here will be executed when an anchor was removed from the session
+     */
+    onAnchorRemovedObservable: Observable<any>;
+    /**
+     * Observers registered here will be executed when an existing anchor updates
+     * This can execute N times every frame
+     */
+    onAnchorUpdatedObservable: Observable<any>;
+    _tmpVector: Vector3;
+    _tmpQuaternion: Quaternion;
+    /**
+     * Set the reference space to use for anchor creation, when not using a hit test.
+     * Will default to the session's reference space if not defined
+     */
+    set referenceSpaceForFrameAnchors(arg: any);
+    _referenceSpaceForFrameAnchors: any;
+    _populateTmpTransformation(position: any, rotationQuaternion: any): {
+        position: Vector3;
+        rotationQuaternion: Quaternion;
+    };
+    /**
+     * Create a new anchor point using a hit test result at a specific point in the scene
+     * An anchor is tracked only after it is added to the trackerAnchors in xrFrame. The promise returned here does not yet guaranty that.
+     * Use onAnchorAddedObservable to get newly added anchors if you require tracking guaranty.
+     *
+     * @param hitTestResult The hit test result to use for this anchor creation
+     * @param position an optional position offset for this anchor
+     * @param rotationQuaternion an optional rotation offset for this anchor
+     * @returns A promise that fulfills when babylon has created the corresponding WebXRAnchor object and tracking has begun
+     */
+    addAnchorPointUsingHitTestResultAsync(hitTestResult: any, position?: Vector3, rotationQuaternion?: Quaternion): Promise<any>;
+    /**
+     * Add a new anchor at a specific position and rotation
+     * This function will add a new anchor per default in the next available frame. Unless forced, the createAnchor function
+     * will be called in the next xrFrame loop to make sure that the anchor can be created correctly.
+     * An anchor is tracked only after it is added to the trackerAnchors in xrFrame. The promise returned here does not yet guaranty that.
+     * Use onAnchorAddedObservable to get newly added anchors if you require tracking guaranty.
+     *
+     * @param position the position in which to add an anchor
+     * @param rotationQuaternion an optional rotation for the anchor transformation
+     * @param forceCreateInCurrentFrame force the creation of this anchor in the current frame. Must be called inside xrFrame loop!
+     * @returns A promise that fulfills when babylon has created the corresponding WebXRAnchor object and tracking has begun
+     */
+    addAnchorAtPositionAndRotationAsync(position: any, rotationQuaternion?: Quaternion, forceCreateInCurrentFrame?: boolean): Promise<any>;
+    /**
+     * Get the list of anchors currently being tracked by the system
+     */
+    get anchors(): any[];
+    _onXRFrame(frame: any): void;
+    /**
+     * avoiding using Array.find for global support.
+     * @param xrAnchor the plane to find in the array
+     */
+    _findIndexInAnchorArray(xrAnchor: any): number;
+    _updateAnchorWithXRFrame(xrAnchor: any, anchor: any, xrFrame: any): any;
+    _createAnchorAtTransformation(xrTransformation: any, xrFrame: any): Promise<any>;
+}
+export namespace WebXRAnchorSystem {
+    const Name: string;
+    const Version: number;
+}
+import { WebXRAbstractFeature } from "./WebXRAbstractFeature.js";
+import { Observable } from "../../Misc/observable.js";
+import { Vector3 } from "../../Maths/math.vector.js";
+import { Quaternion } from "../../Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/XR/features/WebXRBackgroundRemover.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A module that will automatically disable background meshes when entering AR and will enable them when leaving AR.
+ */
+export class WebXRBackgroundRemover extends WebXRAbstractFeature {
+    /**
+     * constructs a new background remover module
+     * @param _xrSessionManager the session manager for this module
+     * @param options read-only options to be used in this module
+     */
+    constructor(_xrSessionManager: any, options?: {});
+    options: {};
+    /**
+     * registered observers will be triggered when the background state changes
+     */
+    onBackgroundStateChangedObservable: Observable<any>;
+    /**
+     * attach this feature
+     * Will usually be called by the features manager
+     *
+     * @returns true if successful.
+     */
+    attach(): boolean;
+    _onXRFrame(_xrFrame: any): void;
+    _setBackgroundState(newState: any): void;
+}
+export namespace WebXRBackgroundRemover {
+    const Name: string;
+    const Version: number;
+}
+import { WebXRAbstractFeature } from "./WebXRAbstractFeature.js";
+import { Observable } from "../../Misc/observable.js";