@tresjs/core 5.9.3 → 5.10.0

package/dist/tres.d.ts

@@ -1,1223 +1,9 @@
 /**
   * name: @tresjs/core
-  * version: v5.9.3
+  * version: v5.10.0
   * (c) 2026
   * description: Declarative ThreeJS using Vue Components
   * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
   */
-import { App, ComputedRef, DefineComponent, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, VNode, VNodeRef } from "vue";
-import * as THREE from "three";
-import { BufferGeometry, Camera, Color, ColorRepresentation, ColorSpace, Event, Fog, Group, Layers, Light, Loader, LoadingManager, Material, Mesh, Object3D, Object3DEventMap, OrthographicCamera, PerspectiveCamera, Scene, ShadowMapType, ToneMapping, Vector3, WebGLRenderer } from "three";
-import { EventHookOff, UseAsyncStateOptions, UseAsyncStateReturn } from "@vueuse/core";
-import { PointerEvent, PointerEventsMap } from "@pmndrs/pointer-events";
-import { Renderer } from "three/webgpu";
-//#region src/composables/useLoader/index.d.ts
-export interface LoaderMethods {
-  setDRACOLoader: (dracoLoader: any) => void;
-  setMeshoptDecoder: (meshoptDecoder: any) => void;
-  setKTX2Loader: (ktx2Loader: any) => void;
-}
-export type TresLoader<T> = Loader & Partial<LoaderMethods> & {
-  load: (url: string, onLoad: (result: T) => void, onProgress?: (event: ProgressEvent<EventTarget>) => void, onError?: (err: unknown) => void) => void;
-  loadAsync: (url: string, onProgress?: (event: ProgressEvent) => void) => Promise<T>;
-};
-export type LoaderProto<T> = new (manager?: LoadingManager) => TresLoader<T>;
-export interface TresLoaderOptions<T, Shallow extends boolean> {
-  manager?: LoadingManager;
-  extensions?: (loader: TresLoader<T>) => void;
-  initialValue?: T;
-  asyncOptions?: UseAsyncStateOptions<Shallow, any | null>;
-}
-/**
- * Return type for the useLoader composable
- * @template T - The type of the loaded asset (e.g., GLTF, Texture, etc.)
- * @template Shallow - Whether to use shallow reactivity for better performance
- * @extends {UseAsyncStateReturn<T, [string], Shallow>} - Extends VueUse's useAsyncState return type
- */
-export type UseLoaderReturn<T, Shallow extends boolean> = UseAsyncStateReturn<T, [string], Shallow> & {
-  /**
-   * Loads a new asset from the given path
-   * @param path - The URL or path to the asset to load
-   */
-  load: (path: string) => void;
-  /**
-   * Progress of the loading process
-   * @property loaded - The number of bytes loaded
-   * @property total - The total number of bytes to load
-   * @property percentage - The percentage of the loading process
-   */
-  progress: {
-    loaded: number;
-    total: number;
-    percentage: number;
-  };
-};
-/**
- * Vue composable for loading 3D models using Three.js loaders
- * @param Loader - The Three.js loader constructor
- * @param path - The path to the model file
- * @param options - Optional configuration for the loader
- * @returns UseAsyncState composable with the loaded model
- */
-export declare function useLoader<T, Shallow extends boolean = true>(Loader: LoaderProto<T>, path: MaybeRef<string>, options?: TresLoaderOptions<T, Shallow>): UseLoaderReturn<T, Shallow>;
-//#endregion
-//#region src/composables/useCreateRafLoop/index.d.ts
-interface RafLoopContext {
-  delta: number;
-  elapsed: number;
-}
-//#endregion
-//#region src/composables/useSizes/index.d.ts
-interface SizesType {
-  width: Readonly<Ref<number>>;
-  height: Readonly<Ref<number>>;
-  pixelRatio: Readonly<Ref<number>>;
-  aspectRatio: ComputedRef<number>;
-}
-//#endregion
-//#region src/composables/useCamera/index.d.ts
-/**
- * Interface for the return value of the useCamera composable
- */
-export interface UseCameraReturn {
-  activeCamera: ComputedRef<TresCamera>;
-  /**
-   * The list of cameras
-   */
-  cameras: ShallowRef<TresCamera[]>;
-  /**
-   * Register a camera
-   * @param camera - The camera to register
-   * @param active - Whether to set the camera as active
-   */
-  registerCamera: (camera: TresCamera, active?: boolean) => void;
-  /**
-   * Deregister a camera
-   * @param camera - The camera to deregister
-   */
-  deregisterCamera: (camera: TresCamera) => void;
-  /**
-   * Set the active camera
-   * @param cameraOrUuid - The camera or its UUID to set as active
-   */
-  setActiveCamera: (cameraOrUuid: string | TresCamera) => void;
-}
-/**
- * Interface for the parameters of the useCamera composable
- */
-interface UseCameraParams {
-  sizes: TresContext['sizes'];
-}
-/**
- * Composable for managing cameras in a Three.js scene
- * @param params - The parameters for the composable
- * @param params.sizes - The sizes object containing window dimensions
- * @returns The camera management functions and state
- */
-export declare const useCameraManager: ({ sizes }: UseCameraParams) => UseCameraReturn;
-//#endregion
-//#region src/utils/error.d.ts
-export type TresRendererErrorCode = 'INITIALIZATION_FAILED';
-export declare class TresRendererError extends Error {
-  readonly code: TresRendererErrorCode;
-  readonly name = "TresRendererError";
-  constructor(message: string, code: TresRendererErrorCode, options?: ErrorOptions);
-}
-//#endregion
-//#region src/composables/useRenderer/useRendererManager.d.ts
-/**
- * If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
- * If set to 'manual', the scene will only be rendered when advance() is called
- * If set to 'always', the scene will be rendered every frame
- */
-export type RenderMode = 'always' | 'on-demand' | 'manual';
-export type RenderFunction = (notifySuccess: () => void) => void;
-export type TresRenderer = WebGLRenderer | Renderer;
-export interface RendererOptions {
-  /**
-   * WebGL Context options (Readonly because they are passed to the renderer constructor)
-   * They can't be changed after the renderer is created because they are passed to the canvas context
-   */
-  antialias?: boolean;
-  /**
-   * Enables stencil buffer with 8 bits.
-   * Required for stencil-based operations like shadow volumes or post-processing effects.
-   * @readonly
-   * @default true
-   */
-  stencil?: boolean;
-  /**
-   * Enables depth buffer with at least 16 bits.
-   * Required for proper 3D rendering and depth testing.
-   * @readonly
-   * @default true
-   */
-  depth?: boolean;
-  /**
-   * Sets the shader precision of the renderer.
-   * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-   * @default 'highp'
-   */
-  precision?: 'highp' | 'mediump' | 'lowp';
-  /**
-   * Enables logarithmic depth buffer. Useful for scenes with large differences in scale.
-   * Helps prevent z-fighting in scenes with objects very close and very far from the camera.
-   * @readonly
-   * @default false
-   */
-  logarithmicDepthBuffer?: boolean;
-  /**
-   * Preserves the buffers until manually cleared or overwritten.
-   * Needed for screenshots or when reading pixels from the canvas.
-   * Warning: This may impact performance.
-   * @readonly
-   * @default false
-   */
-  preserveDrawingBuffer?: boolean;
-  /**
-   * Power preference for the renderer.
-   * Power preference for the renderer.
-   * - `default`: Automatically chooses the most suitable power setting.
-   * - `high-performance`: Prioritizes rendering performance.
-   * - `low-power`: Tries to reduce power usage.
-   * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-   * @default 'default'
-   * @readonly
-   */
-  powerPreference?: WebGLPowerPreference;
-  /**
-   * Whether to create the WebGL context with an alpha buffer.
-   * This is a WebGL context option that must be set during context creation and cannot be changed later.
-   * When true, the canvas can be transparent, showing content behind it.
-   * @readonly
-   * @default false
-   */
-  alpha?: boolean;
-  /**
-   * Whether to premultiply the alpha of the canvas.
-   * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-   * @default true
-   */
-  premultipliedAlpha?: boolean;
-  /**
-   * Whether to fail if the major performance caveat is detected.
-   * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-   * @default false
-   */
-  failIfMajorPerformanceCaveat?: boolean;
-  /**
-   * WebGL options with set methods
-   * @see {@link https://threejs.org/docs/#api/en/renderers/WebGLRenderer}
-   */
-  /**
-   * Clear color for the canvas
-   * Can include alpha value (e.g. '#00808000' for fully transparent teal)
-   */
-  clearColor?: ColorRepresentation;
-  /**
-   * The opacity of the clear color (0-1)
-   * Controls the transparency of the clear color
-   * @default 1
-   */
-  clearAlpha?: number;
-  /**
-   * Enable shadow rendering in the scene
-   * @default false
-   */
-  shadows?: boolean;
-  /**
-   * Tone mapping technique to use for the scene
-   * - `NoToneMapping`: No tone mapping is applied.
-   * - `LinearToneMapping`: Linear tone mapping.
-   * - `ReinhardToneMapping`: Reinhard tone mapping.
-   * - `CineonToneMapping`: Cineon tone mapping.
-   * - `ACESFilmicToneMapping`: ACES Filmic tone mapping.
-   * - `AgXToneMapping`: AgX tone mapping.
-   * - `NeutralToneMapping`: Neutral tone mapping.
-   * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
-   * @default ACESFilmicToneMapping (Opinionated default by TresJS)
-   */
-  toneMapping?: ToneMapping;
-  /**
-   * Type of shadow map to use for shadow calculations
-   * - `BasicShadowMap`: Basic shadow map.
-   * - `PCFShadowMap`: Percentage-Closer Filtering shadow map.
-   * - `PCFSoftShadowMap`: Deprecated. three falls back to `PCFShadowMap` on WebGL, and on WebGPU since r186.
-   * - `VSMShadowMap`: Variance shadow map.
-   * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
-   * @default PCFShadowMap. On WebGPU before r186, PCFSoftShadowMap (Opinionated default by TresJS)
-   */
-  shadowMapType?: ShadowMapType;
-  /**
-   * Whether to use legacy lights system instead of the new one
-   * @deprecated Use `useLegacyLights: false` for the new lighting system
-   */
-  useLegacyLights?: boolean;
-  /**
-   * Color space for the output render
-   * @see {@link https://threejs.org/docs/#api/en/constants/Renderer}
-   */
-  outputColorSpace?: ColorSpace;
-  /**
-   * Exposure level of tone mapping
-   * @default 1
-   */
-  toneMappingExposure?: number;
-  /**
-   * Rendering mode for the canvas
-   * - 'always': Renders every frame
-   * - 'on-demand': Renders only when changes are detected
-   * - 'manual': Renders only when explicitly called
-   * @default 'always'
-   */
-  renderMode?: 'always' | 'on-demand' | 'manual';
-  /**
-   * Device Pixel Ratio for the renderer
-   * Can be a single number or a tuple defining a range [min, max]
-   */
-  dpr?: number | [number, number];
-  /**
-   * Custom WebGL renderer instance
-   * Allows using a pre-configured renderer instead of creating a new one
-   */
-  renderer?: (ctx: TresRendererSetupContext) => TresRenderer;
-}
-export interface TresRendererSetupContext {
-  sizes: SizesType;
-  scene: ShallowRef<TresScene>;
-  camera: UseCameraReturn;
-  canvas: MaybeRef<HTMLCanvasElement>;
-}
-export interface UseRendererOptions {
-  scene: ShallowRef<TresScene>;
-  canvas: MaybeRef<HTMLCanvasElement>;
-  options: Reactive<RendererOptions>;
-  fpsLimit?: MaybeRefOrGetter<number>;
-  contextParts: Pick<TresContext, 'sizes' | 'camera'>;
-}
-export declare function useRendererManager({ scene, canvas, options, fpsLimit, contextParts: { sizes, camera } }: UseRendererOptions): {
-  loop: {
-    start: () => void;
-    stop: () => void;
-    isActive: Readonly<ShallowRef<boolean>>;
-    onBeforeLoop: import("@vueuse/core").EventHookOn<RafLoopContext>;
-    onLoop: import("@vueuse/core").EventHookOn<RafLoopContext>;
-  };
-  instance: TresRenderer;
-  advance: () => void;
-  onReady: import("@vueuse/core").EventHookOn<TresRenderer>;
-  onRender: import("@vueuse/core").EventHookOn<TresRenderer>;
-  onError: import("@vueuse/core").EventHookOn<TresRendererError>;
-  invalidate: (amountOfFramesToInvalidate?: number) => void;
-  canBeInvalidated: import("vue").ComputedRef<boolean>;
-  mode: "always" | "on-demand" | "manual" | undefined;
-  replaceRenderFunction: (fn: RenderFunction) => void;
-  isInitialized: import("vue").Ref<boolean, boolean>;
-  error: import("vue").Ref<TresRendererError | null, TresRendererError | null>;
-};
-export type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;
-//#endregion
-//#region src/composables/useEventManager/index.d.ts
-declare function useEventManager({ canvas, contextParts: { scene, camera, renderer } }: {
-  canvas: MaybeRef<HTMLCanvasElement>;
-  contextParts: Pick<TresContext, 'scene' | 'camera' | 'renderer'>;
-}): {
-  onPointerMissed: import("@vueuse/core").EventHookOn<TresPointerEvent & Event<"click", Object3D<Object3DEventMap & PointerEventsMap>>>;
-};
-//#endregion
-//#region src/composables/useTresContextProvider/index.d.ts
-interface TresContext {
-  scene: ShallowRef<TresScene>;
-  sizes: SizesType;
-  extend: (objects: any) => void;
-  camera: UseCameraReturn;
-  controls: Ref<TresControl | null>;
-  renderer: UseRendererManagerReturn;
-  /**
-   * Whether the active renderer is a Three.js WebGPU `Renderer` (as opposed to a
-   * `WebGLRenderer`). Reactive so downstream components can branch on it without
-   * re-deriving it from `renderer.instance`.
-   *
-   * Note: this reflects the renderer instance, not the active backend — a
-   * `WebGPURenderer` running on its WebGL2 fallback still reports `true`.
-   */
-  isWebGPU: ComputedRef<boolean>;
-  events: ReturnType<typeof useEventManager>;
-}
-export declare const INJECTION_KEY = "useTres";
-declare const useTresContextProvider: (args_0: {
-  scene: TresScene;
-  canvas: MaybeRef<HTMLCanvasElement>;
-  fpsLimit?: MaybeRefOrGetter<number>;
-  windowSize: MaybeRefOrGetter<boolean>;
-  rendererOptions: RendererOptions;
-}) => TresContext;
-declare const useTresContext: () => TresContext;
-//#endregion
-//#region src/utils/pointerEvents.d.ts
-declare const supportedPointerEvents: readonly ["onClick", "onContextmenu", "onPointermove", "onPointerenter", "onPointerleave", "onPointerover", "onPointerout", "onDblclick", "onPointerdown", "onPointerup", "onPointercancel", "onLostpointercapture", "onWheel"];
-type SupportedVuePointerEvent = typeof supportedPointerEvents[number];
-type TresPointerEventName = 'click' | 'contextmenu' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerover' | 'pointerout' | 'dblclick' | 'pointerdown' | 'pointerup' | 'pointercancel' | 'lostpointercapture' | 'wheel';
-type TresPointerEvent = PointerEvent<MouseEvent>;
-type PointerEventHandlers = { [key in SupportedVuePointerEvent]: (event: TresPointerEvent) => void; };
-//#endregion
-//#region src/types/index.d.ts
-export type AttachFnType = (parent: any, self: TresInstance) => () => void;
-export type AttachType = string | AttachFnType;
-export type DisposeType = ((self: TresInstance) => void) | boolean | 'default' | null;
-export type ConstructorRepresentation = new (...args: any[]) => any;
-export type NonFunctionKeys<P> = { [K in keyof P]-?: P[K] extends ((...args: any[]) => any) ? never : K; }[keyof P];
-export type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
-export type Properties<T> = Pick<T, NonFunctionKeys<T>>;
-export type Mutable<P> = { [K in keyof P]: P[K] | Readonly<P[K]>; };
-export type Args<T> = T extends ConstructorRepresentation ? ConstructorParameters<T> : any[];
-export interface TresCatalogue {
-  [name: string]: ConstructorRepresentation;
-}
-export type TresCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-/**
- * Represents the properties of an instance.
- *
- * @template T - The type of the object.
- * @template P - The type of the arguments.
- */
-export interface InstanceProps<T = any, P = any> {
-  args?: Args<P>;
-  object?: T;
-  visible?: boolean;
-  dispose?: null;
-  attach?: AttachType;
-}
-interface TresBaseObject {
-  removeFromParent?: () => void;
-  dispose?: () => void;
-  [prop: string]: any;
-}
-export interface LocalState {
-  type: string;
-  root: TresContext;
-  memoizedProps: {
-    [key: string]: any;
-  };
-  objects: TresObject[];
-  parent: TresObject | null;
-  primitive?: boolean;
-  dispose?: DisposeType;
-  attach?: AttachType;
-  previousAttach: any;
-}
-export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
-  geometry?: THREE.BufferGeometry & TresBaseObject;
-  material?: THREE.Material & TresBaseObject;
-}
-export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
-  __tres?: LocalState;
-};
-/**
- * Union type covering all common Three.js material types
- * This provides better TypeScript intellisense and type checking
- * when accessing specific material properties
- */
-export type TresMaterial = THREE.MeshBasicMaterial | THREE.MeshStandardMaterial | THREE.MeshPhysicalMaterial | THREE.MeshLambertMaterial | THREE.MeshPhongMaterial | THREE.MeshToonMaterial | THREE.MeshNormalMaterial | THREE.MeshMatcapMaterial | THREE.MeshDepthMaterial | THREE.MeshDistanceMaterial | THREE.LineBasicMaterial | THREE.LineDashedMaterial | THREE.PointsMaterial | THREE.SpriteMaterial | THREE.ShaderMaterial | THREE.RawShaderMaterial | THREE.ShadowMaterial | THREE.Material;
-export type TresInstance = TresObject & {
-  __tres: LocalState;
-};
-export type TresPrimitive = TresInstance & {
-  object: TresInstance;
-  isPrimitive: true;
-};
-export interface TresScene extends THREE.Scene {
-  __tres: {
-    root: TresContext;
-    objects: TresObject[];
-    isUnmounting: boolean;
-  };
-}
-interface MathRepresentation {
-  set(...args: number[]): any;
-}
-interface VectorRepresentation extends MathRepresentation {
-  setScalar(s: number): any;
-}
-type MathTypes = MathRepresentation | THREE.Euler | THREE.Color;
-export interface VectorCoordinates {
-  x: number;
-  y: number;
-  z: number;
-}
-export type MathType<T extends MathTypes> = T extends THREE.Color ? ConstructorParameters<typeof THREE.Color> | THREE.ColorRepresentation : T extends VectorRepresentation | THREE.Layers | THREE.Euler ? T | Parameters<T['set']> | number | VectorCoordinates : T | Parameters<T['set']>;
-type VectorLike$1<VectorClass extends THREE.Vector2 | THREE.Vector3 | THREE.Vector4> = VectorClass | Parameters<VectorClass['set']> | Readonly<Parameters<VectorClass['set']>> | Parameters<VectorClass['setScalar']>[0];
-export type TresVector2 = VectorLike$1<THREE.Vector2>;
-export type TresVector3 = VectorLike$1<THREE.Vector3>;
-export type TresVector4 = VectorLike$1<THREE.Vector4>;
-export type TresColor = ConstructorParameters<typeof THREE.Color> | THREE.Color | number | string;
-export type TresColorArray = typeof THREE.Color | [color: THREE.ColorRepresentation];
-export type TresLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];
-export type TresQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
-export type TresEuler = THREE.Euler;
-export type TresControl = THREE.EventDispatcher & {
-  enabled: boolean;
-};
-export type TresContextWithClock = TresContext & {
-  delta: number;
-  elapsed: number;
-};
-export type WithMathProps<P> = { [K in keyof P]: P[K] extends MathTypes ? MathType<P[K]> : P[K]; };
-interface RaycastableRepresentation {
-  raycast: (raycaster: THREE.Raycaster, intersects: THREE.Intersection[]) => void;
-}
-type EventProps<P> = P extends RaycastableRepresentation ? Partial<PointerEventHandlers> : unknown;
-export interface VueProps {
-  children?: VNode[];
-  ref?: VNodeRef;
-  key?: string | number | symbol;
-}
-export type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, WithMathProps<P> & VueProps & EventProps<P>>>;
-export type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>>;
-type ThreeExports = typeof THREE;
-type ThreeInstancesImpl = { [K in keyof ThreeExports as Uncapitalize<K>]: ThreeExports[K] extends ConstructorRepresentation ? ThreeElement<ThreeExports[K]> : never; };
-export interface ThreeInstances extends ThreeInstancesImpl {
-  primitive: Omit<ThreeElement<any>, 'args'> & {
-    object: object;
-  };
-}
-export type TresComponents = { [K in keyof ThreeInstances as `Tres${Capitalize<string & K>}`]: DefineComponent<ThreeInstances[K]>; };
-declare module 'vue' {
-  interface GlobalComponents extends TresComponents {
-    primitive: DefineComponent<TresPrimitive>;
-  }
-}
-//#endregion
-//#region src/utils/graph.d.ts
-export interface TresObjectMap {
-  nodes: {
-    [name: string]: TresObject;
-  };
-  materials: {
-    [name: string]: TresMaterial;
-  };
-  meshes: {
-    [name: string]: Mesh;
-  };
-  scene?: Scene;
-}
-export declare function buildGraph(object: Object3D | TresObject): TresObjectMap;
-//#endregion
-//#region src/composables/useLoader/component.vue.d.ts
-declare const __VLS_export$3: <T extends TresObjectMap>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-  props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-    /**
-     * The THREE.js loader to use
-     */
-    loader: LoaderProto<T>;
-    /**
-     * Path to resource
-     */
-    path: string;
-    /**
-     * Optional THREE.js LoadingManager
-     */
-    manager?: LoadingManager;
-    extensions?: (res: T) => void;
-  } & {
-    onError?: ((error: unknown) => any) | undefined;
-    onLoaded?: ((result: T) => any) | undefined;
-  }> & (typeof globalThis extends {
-    __VLS_PROPS_FALLBACK: infer P;
-  } ? P : {});
-  expose: (exposed: {}) => void;
-  attrs: any;
-  slots: {
-    default?: (props: {
-      state: T;
-      isLoading: boolean;
-      error: unknown;
-    }) => any;
-  };
-  emit: ((evt: "error", error: unknown) => void) & ((evt: "loaded", result: T) => void);
-}>) => import("vue").VNode & {
-  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
-};
-declare const _default$3: typeof __VLS_export$3;
-type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
-//#endregion
-//#region src/composables/useGraph/index.d.ts
-export declare const useGraph: (object: MaybeRef<TresObject | undefined>) => import("vue").ComputedRef<TresObjectMap | undefined>;
-//#endregion
-//#region src/utils/createPriorityEventHook.d.ts
-type Callback<T> = Parameters<EventHookOff<T>>[0];
-type PriorityEventHookOn<T> = (fn: Callback<T>, priority?: number) => {
-  off: () => void;
-};
-//#endregion
-//#region src/composables/useTres/index.d.ts
-export interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
-  /**
-   * The renderer instance
-   *
-   * @type {TresRenderer}
-   * @memberof TresPartialContext
-   */
-  renderer: TresRenderer;
-  /**
-   * The current active camera
-   *
-   * @type {ComputedRef<Camera | undefined>}
-   * @memberof TresPartialContext
-   */
-  camera: ComputedRef<Camera | undefined>;
-  /**
-   * Marks the scene as needing an update in the next frame.
-   * This is used in on-demand rendering mode to schedule a render.
-   *
-   * @type {() => void}
-   * @memberof TresPartialContext
-   */
-  invalidate: () => void;
-  /**
-   * Manually advances the render loop by one frame.
-   * This is particularly useful in manual rendering mode where you want explicit control over when frames are rendered.
-   *
-   * @type {() => void}
-   * @memberof TresPartialContext
-   */
-  advance: () => void;
-}
-export declare function useTres(): TresPartialContext;
-//#endregion
-//#region src/composables/useLoop/index.d.ts
-export type LoopContext = RafLoopContext & TresPartialContext;
-/**
- * Composable that provides control over the render loop and animation lifecycle.
- */
-export declare const useLoop: () => {
-  stop: () => void;
-  start: () => void;
-  isActive: Readonly<import("vue").ShallowRef<boolean>>;
-  onBeforeRender: PriorityEventHookOn<LoopContext>;
-  onRender: PriorityEventHookOn<LoopContext>;
-  render: (fn: RenderFunction) => void;
-};
-//#endregion
-//#region src/core/nodeOps.d.ts
-interface TresCustomRendererOptions {
-  primitivePrefix?: string;
-}
-//#endregion
-//#region src/utils/logger.d.ts
-/**
- * Logger utility for TresJS
- * @module logger
- */
-export declare const isProd: boolean;
-type OneOrMore<T> = {
-  0: T;
-} & Array<T>;
-/**
- * Logs an error message with the TresJS prefix
- * @param args - Arguments to log
- */
-export declare function logError(...args: OneOrMore<any>): void;
-/**
- * Logs a warning message with the TresJS prefix
- * @param args - Arguments to log
- */
-export declare function logWarning(...args: OneOrMore<any>): void;
-/**
- * Logs a message with the TresJS prefix (only in development mode)
- * @param name - Name of the message
- * @param value - Value to log
- */
-export declare function logMessage(name: string, value: any): void;
-//#endregion
-//#region src/utils/index.d.ts
-declare function disposeObject3D(object: TresObject): void;
-//#endregion
-//#region src/utils/normalize.d.ts
-interface Vector2PropInterface {
-  x?: number;
-  y?: number;
-  width?: number;
-  height?: number;
-}
-interface Vector3PropInterface extends Vector2PropInterface {
-  z?: number;
-}
-type VectorFlexibleParams = Vector3 | number[] | Vector3PropInterface | number;
-export declare function normalizeVectorFlexibleParam(value: VectorFlexibleParams): Array<number>;
-export declare function normalizeColor(value: Color | Array<number> | string | number | ColorRepresentation): Color;
-//#endregion
-//#region src/utils/template-compiler-options.d.ts
-declare const templateCompilerOptions: {
-  template: {
-    compilerOptions: {
-      isCustomElement: (tag: string) => boolean;
-    };
-  };
-};
-//#endregion
-//#region src/components/Context.vue.d.ts
-interface ContextProps extends RendererOptions {
-  /**
-   * Custom camera instance to use as main camera
-   * If not provided, a default PerspectiveCamera will be created
-   */
-  camera?: TresCamera;
-  /**
-   * Whether the canvas should be sized to the window
-   * When true, canvas will be fixed positioned and full viewport size
-   * @default false
-   */
-  windowSize?: boolean;
-  /**
-   * The maximum number of frames per second to render
-   * @default undefined
-   */
-  fpsLimit?: number;
-  /**
-   * Whether to enable the provide/inject bridge between Vue and TresJS
-   * When true, Vue's provide/inject will work across the TresJS boundary
-   * @default true
-   */
-  enableProvideBridge?: boolean;
-  /**
-   * Options for the TresJS custom renderer
-   *
-   */
-  customRendererOptions?: TresCustomRendererOptions;
-}
-type ContextEmits = {
-  ready: [context: TresContext];
-  error: [error: Error];
-  pointermissed: [event: TresPointerEvent];
-  render: [context: TresContext];
-  beforeLoop: [context: TresContextWithClock];
-  loop: [context: TresContextWithClock];
-} & { [key in TresPointerEventName]: [event: TresPointerEvent]; };
-type __VLS_Props$1 = ContextProps & {
-  canvas: HTMLCanvasElement;
-};
-type __VLS_Slots$2 = {
-  default: () => any;
-};
-declare const __VLS_base$2: import("vue").DefineComponent<__VLS_Props$1, {
-  context: import("vue").ShallowRef<TresContext, TresContext>;
-  dispose: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  render: (context: TresContext) => any;
-  click: (event: TresPointerEvent) => any;
-  contextmenu: (event: TresPointerEvent) => any;
-  pointermove: (event: TresPointerEvent) => any;
-  pointerenter: (event: TresPointerEvent) => any;
-  pointerleave: (event: TresPointerEvent) => any;
-  pointerover: (event: TresPointerEvent) => any;
-  pointerout: (event: TresPointerEvent) => any;
-  dblclick: (event: TresPointerEvent) => any;
-  pointerdown: (event: TresPointerEvent) => any;
-  pointerup: (event: TresPointerEvent) => any;
-  pointercancel: (event: TresPointerEvent) => any;
-  lostpointercapture: (event: TresPointerEvent) => any;
-  wheel: (event: TresPointerEvent) => any;
-  ready: (context: TresContext) => any;
-  error: (error: Error) => any;
-  pointermissed: (event: TresPointerEvent) => any;
-  beforeLoop: (context: TresContextWithClock) => any;
-  loop: (context: TresContextWithClock) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props$1> & Readonly<{
-  onRender?: ((context: TresContext) => any) | undefined;
-  onClick?: ((event: TresPointerEvent) => any) | undefined;
-  onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
-  onPointermove?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerenter?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerleave?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerover?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerout?: ((event: TresPointerEvent) => any) | undefined;
-  onDblclick?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerdown?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerup?: ((event: TresPointerEvent) => any) | undefined;
-  onPointercancel?: ((event: TresPointerEvent) => any) | undefined;
-  onLostpointercapture?: ((event: TresPointerEvent) => any) | undefined;
-  onWheel?: ((event: TresPointerEvent) => any) | undefined;
-  onReady?: ((context: TresContext) => any) | undefined;
-  onError?: ((error: Error) => any) | undefined;
-  onPointermissed?: ((event: TresPointerEvent) => any) | undefined;
-  onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
-  onLoop?: ((context: TresContextWithClock) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
-declare const _default$1: typeof __VLS_export$2;
-type __VLS_WithSlots$2<T, S> = T & {
-  new (): {
-    $slots: S;
-  };
-};
-//#endregion
-//#region src/components/TresCanvas.vue.d.ts
-type TresCanvasEmits = ContextEmits;
-type TresCanvasProps = ContextProps;
-interface TresCanvasInstance {
-  get context(): TresContext | undefined;
-  dispose: () => void;
-}
-type __VLS_Slots$1 = {
-  default: () => any;
-};
-declare const __VLS_base$1: import("vue").DefineComponent<ContextProps, TresCanvasInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  render: (context: TresContext) => any;
-  click: (event: TresPointerEvent) => any;
-  contextmenu: (event: TresPointerEvent) => any;
-  pointermove: (event: TresPointerEvent) => any;
-  pointerenter: (event: TresPointerEvent) => any;
-  pointerleave: (event: TresPointerEvent) => any;
-  pointerover: (event: TresPointerEvent) => any;
-  pointerout: (event: TresPointerEvent) => any;
-  dblclick: (event: TresPointerEvent) => any;
-  pointerdown: (event: TresPointerEvent) => any;
-  pointerup: (event: TresPointerEvent) => any;
-  pointercancel: (event: TresPointerEvent) => any;
-  lostpointercapture: (event: TresPointerEvent) => any;
-  wheel: (event: TresPointerEvent) => any;
-  ready: (context: TresContext) => any;
-  error: (error: Error) => any;
-  pointermissed: (event: TresPointerEvent) => any;
-  beforeLoop: (context: TresContextWithClock) => any;
-  loop: (context: TresContextWithClock) => any;
-}, string, import("vue").PublicProps, Readonly<ContextProps> & Readonly<{
-  onRender?: ((context: TresContext) => any) | undefined;
-  onClick?: ((event: TresPointerEvent) => any) | undefined;
-  onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
-  onPointermove?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerenter?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerleave?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerover?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerout?: ((event: TresPointerEvent) => any) | undefined;
-  onDblclick?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerdown?: ((event: TresPointerEvent) => any) | undefined;
-  onPointerup?: ((event: TresPointerEvent) => any) | undefined;
-  onPointercancel?: ((event: TresPointerEvent) => any) | undefined;
-  onLostpointercapture?: ((event: TresPointerEvent) => any) | undefined;
-  onWheel?: ((event: TresPointerEvent) => any) | undefined;
-  onReady?: ((context: TresContext) => any) | undefined;
-  onError?: ((error: Error) => any) | undefined;
-  onPointermissed?: ((event: TresPointerEvent) => any) | undefined;
-  onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
-  onLoop?: ((context: TresContextWithClock) => any) | undefined;
-}>, {
-  alpha: boolean;
-  logarithmicDepthBuffer: boolean;
-  toneMapping: import("three").ToneMapping;
-  depth: boolean;
-  stencil: boolean;
-  clearColor: import("three").ColorRepresentation;
-  windowSize: boolean;
-  enableProvideBridge: boolean;
-  customRendererOptions: TresCustomRendererOptions;
-  antialias: boolean;
-  preserveDrawingBuffer: boolean;
-  failIfMajorPerformanceCaveat: boolean;
-  clearAlpha: number;
-  shadows: boolean;
-  shadowMapType: import("three").ShadowMapType;
-  useLegacyLights: boolean;
-  renderMode: "always" | "on-demand" | "manual";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
-declare const _default: typeof __VLS_export$1;
-type __VLS_WithSlots$1<T, S> = T & {
-  new (): {
-    $slots: S;
-  };
-};
-//#endregion
-//#region src/components/TresPortal.vue.d.ts
-type __VLS_Props = {
-  /** Target Object3D/Scene to reparent children into. */
-  to: Object3D;
-  /** When true, children render in place (main scene) instead of the target. */
-  disabled?: boolean;
-};
-declare var __VLS_7: {};
-type __VLS_Slots = {} & {
-  default?: (props: typeof __VLS_7) => any;
-};
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default$2: typeof __VLS_export;
-type __VLS_WithSlots<T, S> = T & {
-  new (): {
-    $slots: S;
-  };
-};
-//#endregion
-//#region src/core/catalogue.d.ts
-export declare const catalogue: Ref<TresCatalogue>;
-export declare const extend: (objects: any) => any;
-//#endregion
-//#region src/devtools/DevtoolsMessenger.d.ts
-export type DevtoolsMessageType = 'performance' | 'context' | 'asset-load';
-export interface AssetLoadData {
-  url: string;
-  type: string;
-  loaded: boolean;
-  size: number;
-  asset: HTMLImageElement | HTMLScriptElement | HTMLLinkElement | Blob | ArrayBuffer | null;
-}
-export interface DevtoolsMessage<T = any> {
-  type: DevtoolsMessageType;
-  data: T;
-  timestamp?: number;
-}
-export type DevtoolsSubscriber = (message: DevtoolsMessage) => void;
-/**
- * Messenger class for communicating with Tres DevTools
- * This class will be attached to window.__TRES__DEVTOOLS__
- */
-export declare class DevtoolsMessenger {
-  private subscribers;
-  private messageQueue;
-  private maxQueueSize;
-  /**
-   * Send a message to devtools subscribers
-   * If no subscribers are available, only queueable message types are queued
-   */
-  send<T>(type: DevtoolsMessageType, data: T): void;
-  /**
-   * Queue a message for later delivery
-   */
-  private queueMessage;
-  /**
-   * Flush all queued messages to current subscribers
-   */
-  private flushQueue;
-  /**
-   * Subscribe to devtools messages
-   * When a new subscriber is added, all queued messages (asset-load events) are immediately delivered
-   */
-  subscribe(subscriber: DevtoolsSubscriber): () => void;
-  /**
-   * Check if there are any subscribers
-   */
-  get hasSubscribers(): boolean;
-  /**
-   * Get the current queue size
-   */
-  get queueSize(): number;
-  /**
-   * Clear all queued messages
-   */
-  clearQueue(): void;
-}
-//#endregion
-//#region src/devtools/plugin.d.ts
-export declare function registerTresDevtools(app: App, tres: TresContext): void;
-//#endregion
-//#region src/directives/vDistanceTo.d.ts
-export declare const vDistanceTo: {
-  updated: (el: TresObject, binding: Ref<TresObject>) => void;
-  unmounted: (el: TresObject) => void;
-};
-//#endregion
-//#region src/directives/vLightHelper.d.ts
-export declare const vLightHelper: {
-  mounted: (el: TresObject) => void;
-  updated: (el: TresObject) => void;
-  unmounted: (el: TresObject) => void;
-};
-//#endregion
-//#region src/directives/vLog.d.ts
-export declare const vLog: {
-  mounted: (el: TresObject, binding: {
-    arg: string;
-  }) => void;
-};
-//#endregion
-//#region src/utils/createTimer.d.ts
-export interface TresTimer {
-  getDelta: () => number;
-  getElapsed: () => number;
-  update: () => void;
-  start: () => void;
-  stop: () => void;
-}
-/**
- * Creates a unified timer abstraction that uses `Timer` on Three.js r179+
- * and falls back to `Clock` on older versions.
- *
- * - On r179+: uses `Timer` with its Page Visibility API support (`connect`/`disconnect`).
- * - On older versions: uses `Clock` with `start`/`stop`.
- *
- */
-export declare function createTimer(): TresTimer;
-//#endregion
-//#region src/utils/is/three.d.ts
-/**
- * Type guard to check if a value is a Three.js Object3D
- * @param value - The value to check
- * @returns True if the value is a Three.js Object3D instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.Object3D()
- * if (isObject3D(value)) {
- *   // TypeScript knows value is Object3D here
- *   value.position // OK
- *   value.rotation // OK
- *   value.scale // OK
- * }
- * ```
- */
-export declare const isObject3D: (value: unknown) => value is Object3D<import("three").Object3DEventMap>;
-/**
- * Type guard to check if a value is a Three.js Mesh
- * @param value - The value to check
- * @returns True if the value is a Three.js Mesh instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.Mesh()
- * if (isMesh(value)) {
- *   // TypeScript knows value is Mesh here
- *   value.geometry // OK
- */
-export declare const isMesh: (value: unknown) => value is Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, Material<import("three").MaterialEventMap> | Material<import("three").MaterialEventMap>[], import("three").Object3DEventMap>;
-/**
- * Type guard to check if a value is a Three.js Camera
- * @param value - The value to check
- * @returns True if the value is a Three.js Camera instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.PerspectiveCamera()
- * if (isCamera(value)) {
- *   // TypeScript knows value is Camera here
- *   value.fov // OK
- *   value.near // OK
- *   value.far // OK
- * }
- * ```
- */
-export declare const isCamera: (value: unknown) => value is Camera;
-/**
- * Type guard to check if a value is a Three.js OrthographicCamera
- * @param value - The value to check
- * @returns True if the value is a Three.js OrthographicCamera instance, false otherwise
- */
-export declare const isOrthographicCamera: (value: unknown) => value is OrthographicCamera;
-/**
- * Type guard to check if a value is a Three.js PerspectiveCamera
- * @param value - The value to check
- * @returns True if the value is a Three.js PerspectiveCamera instance, false otherwise
- */
-export declare const isPerspectiveCamera: (value: unknown) => value is PerspectiveCamera;
-/**
- * Type guard to check if a value is a Three.js Color
- * @param value - The value to check
- * @returns True if the value is a Three.js Color instance, false otherwise
- */
-export declare const isColor: (value: unknown) => value is Color;
-/**
- * Type guard to check if a value is a Three.js ColorRepresentation
- * @param value - The value to check
- * @returns True if the value is a Three.js ColorRepresentation instance, false otherwise
- */
-export declare const isColorRepresentation: (value: unknown) => value is ColorRepresentation;
-/**
- * Type guard to check if a value is a Three.js Layers
- * @param value - The value to check
- * @returns True if the value is a Three.js Layers instance, false otherwise
- */
-export declare const isLayers: (value: unknown) => value is Layers;
-/**
- * Type guard to check if a value is a Three.js BufferGeometry
- * @param value - The value to check
- * @returns True if the value is a Three.js BufferGeometry instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.BufferGeometry()
- * if (isBufferGeometry(value)) {
- *   // TypeScript knows value is BufferGeometry here
- *   value.attributes // OK
- *   value.index // OK
- *   value.computeVertexNormals() // OK
- * }
- * ```
- */
-export declare const isBufferGeometry: (value: unknown) => value is BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
-/**
- * Type guard to check if a value is a Three.js Material
- * @param value - The value to check
- * @returns True if the value is a Three.js Material instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.MeshStandardMaterial()
- * if (isMaterial(value)) {
- *   // TypeScript knows value is Material here
- *   value.color // OK
- *   value.metalness // OK
- *   value.roughness // OK
- * }
- * ```
- */
-export declare const isMaterial: (value: unknown) => value is Material<import("three").MaterialEventMap>;
-/**
- * Type guard to check if a value is a Three.js Light
- * @param value - The value to check
- * @returns True if the value is a Three.js Light instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.DirectionalLight()
- * if (isLight(value)) {
- *   // TypeScript knows value is Light here
- *   value.intensity // OK
- *   value.color // OK
- *   value.position // OK
- * }
- * ```
- */
-export declare const isLight: (value: unknown) => value is Light;
-/**
- * Type guard to check if a value is a Three.js Fog
- * @param value - The value to check
- * @returns True if the value is a Three.js Fog instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.Fog(0x000000, 1, 1000)
- * if (isFog(value)) {
- *   // TypeScript knows value is Fog here
- *   value.color // OK
- *   value.near // OK
- *   value.far // OK
- * }
- * ```
- */
-export declare const isFog: (value: unknown) => value is Fog;
-/**
- * Type guard to check if a value is a Three.js Scene
- * @param value - The value to check
- * @returns True if the value is a Three.js Scene instance, false otherwise
- * @example
- * ```ts
- * const value = new THREE.Scene()
- * if (isScene(value)) {
- *   // TypeScript knows value is Scene here
- *   value.children // OK
- *   value.add(new THREE.Object3D()) // OK
- *   value.remove(new THREE.Object3D()) // OK
- * }
- * ```
- */
-export declare const isScene: (value: unknown) => value is Scene<import("three").Object3DEventMap>;
-/**
- * Type guard to check if a value is a Three.js Group
- * @param value - The value to check
- * @returns True if the value is a Three.js Group instance, false otherwise
- * ```
- */
-export declare const isGroup: (value: unknown) => value is Group<import("three").Object3DEventMap>;
-//#endregion
-//#region src/utils/is/tres.d.ts
-interface VectorLike {
-  set: (...args: any[]) => void;
-  constructor?: (...args: any[]) => any;
-}
-export declare const isVectorLike: (value: unknown) => value is VectorLike;
-interface Copyable {
-  copy: (...args: any[]) => void;
-  constructor?: (...args: any[]) => any;
-}
-export declare const isCopyable: (value: unknown) => value is Copyable;
-interface ClassInstance {
-  constructor?: (...args: any[]) => any;
-}
-export declare const isClassInstance: (object: unknown) => object is ClassInstance;
-/**
- * Type guard to check if a value is a TresCamera
- * @param value - The value to check
- * @returns True if the value is a TresCamera instance, false otherwise
- */
-export declare const isTresCamera: (value: unknown) => value is TresCamera;
-/**
- * Type guard to check if a value is a TresObject
- * @param value - The value to check
- * @returns True if the value is a TresObject (Object3D | BufferGeometry | Material | Fog), false otherwise
- * @example
- * ```ts
- * const value = new THREE.Mesh()
- * if (isTresObject(value)) {
- *   // TypeScript knows value is TresObject here
- *   // You can use common properties and methods shared by all TresObjects
- * }
- * ```
- * @remarks
- * TresObject is a union type that represents the core Three.js objects that can be used in TresJS.
- * This includes Object3D, BufferGeometry, Material, and Fog instances.
- */
-export declare const isTresObject: (value: unknown) => value is TresObject;
-/**
- * Type guard to check if a value is a TresPrimitive
- * @param value - The value to check
- * @returns True if the value is a TresPrimitive instance, false otherwise
- * @example
- * ```ts
- * const value = { isPrimitive: true }
- * if (isTresPrimitive(value)) {
- *   // TypeScript knows value is TresPrimitive here
- *   // You can use properties and methods specific to TresPrimitives
- * }
- * ```
- * @remarks
- * TresPrimitive is a special type in TresJS that represents primitive objects
- * that can be used directly in the scene without needing to be wrapped in a Three.js object.
- */
-export declare const isTresPrimitive: (value: unknown) => value is TresPrimitive;
-/**
- * Type guard to check if a value is a TresInstance (has __tres property)
- * @param value - The value to check
- * @returns True if the value is a TresInstance (has __tres property), false otherwise
- * @example
- * ```ts
- * const value = new THREE.Mesh()
- * if (isTresInstance(value)) {
- *   // TypeScript knows value is TresInstance here
- *   // You can safely access value.__tres
- * }
- * ```
- */
-export declare const isTresInstance: (value: unknown) => value is TresInstance;
-/**
- * Type guard to check if a value is a Three.js WebGPU `Renderer`.
- *
- * Identifies the renderer *instance*, not the active backend: a `WebGPURenderer`
- * can run on a WebGPU **or** a WebGL2 fallback backend, and this returns `true`
- * for both. That is the right granularity for branching on capabilities —
- * `NodeMaterial` works on either backend, while a GLSL `ShaderMaterial` works on
- * neither under the WebGPU renderer.
- * @param value - The value to check
- * @returns True if the value is a WebGPU `Renderer` instance, false otherwise
- * @example
- * ```ts
- * const { renderer } = useTresContext()
- * if (isWebGPURenderer(renderer.instance)) {
- *   // TypeScript knows renderer.instance is a WebGPU Renderer here
- * }
- * ```
- */
-export declare const isWebGPURenderer: (value: unknown) => value is Renderer;
-/**
- * Type guard to check if a value is a Three.js `WebGLRenderer`.
- * @param value - The value to check
- * @returns True if the value is a `WebGLRenderer` instance, false otherwise
- * @see {@link isWebGPURenderer}
- */
-export declare const isWebGLRenderer: (value: unknown) => value is WebGLRenderer & {
-  isWebGLRenderer: true;
-};
-//#endregion
-//#region src/index.d.ts
-export interface TresOptions {
-  extends?: Record<string, unknown>;
-}
-export interface TresPlugin {
-  [key: string]: any;
-  install: (app: App, options?: TresOptions) => void;
-}
-declare const plugin: TresPlugin;
-//#endregion
-export { _default as TresCanvas, _default$1 as TresCanvasContext, type TresCanvasEmits, type TresCanvasInstance, type TresCanvasProps, type TresContext, type TresCustomRendererOptions, type TresPointerEvent, _default$2 as TresPortal, _default$3 as UseLoader, type VectorFlexibleParams, plugin as default, disposeObject3D as dispose, templateCompilerOptions, useTresContext, useTresContextProvider };
+import { $ as isProd, $t as TresPointerEvent, A as createTimer, At as TresCamera, B as catalogue, Bt as TresLayers, C as isNode, Ct as Mutable, D as isPerspectiveCamera, Dt as ThreeElement, E as isOrthographicCamera, Et as Properties, F as AssetLoadData, Ft as TresComponentsOf, G as TresCanvasEmits, Gt as TresQuaternion, H as _default$2, Ht as TresObject, I as DevtoolsMessage, It as TresContextWithClock, J as templateCompilerOptions, Jt as TresVector3, K as TresCanvasInstance, Kt as TresScene, L as DevtoolsMessageType, Lt as TresControl, M as vLightHelper, Mt as TresColor, N as vDistanceTo, Nt as TresColorArray, O as isScene, Ot as ThreeInstances, P as registerTresDevtools, Pt as TresComponents, Q as disposeObject3D, Qt as WithMathProps, R as DevtoolsMessenger, Rt as TresEuler, S as isMesh, St as MathType, T as isObject3D, Tt as Overwrite, U as _default$1, Ut as TresObject3D, V as extend, Vt as TresMaterial, W as _default, Wt as TresPrimitive, X as normalizeColor, Xt as VectorCoordinates, Y as VectorFlexibleParams, Yt as TresVector4, Z as normalizeVectorFlexibleParam, Zt as VueProps, _ as isFog, _n as LoaderProto, _t as ConstructorRepresentation, a as isCopyable, an as RenderMode, at as useLoop, b as isLight, bn as UseLoaderReturn, bt as InstanceProps, c as isTresObject, cn as TresRendererSetupContext, ct as useGraph, d as isWebGLRenderer, dn as TresRendererError, dt as _default$3, en as INJECTION_KEY, et as logError, f as isWebGPURenderer, fn as TresRendererErrorCode, ft as TresObjectMap, g as isColorRepresentation, gn as LoaderMethods, gt as AttachType, h as isColor, ht as AttachFnType, i as isClassInstance, in as RenderFunction, it as LoopContext, j as vLog, jt as TresCatalogue, k as TresTimer, kt as ThreeInstancesOf, l as isTresPrimitive, ln as UseRendererManagerReturn, lt as useRendererManager, m as isCamera, mn as useCameraManager, mt as Args, n as TresPlugin, nt as logWarning, o as isTresCamera, on as RendererOptions, ot as TresPartialContext, p as isBufferGeometry, pn as UseCameraReturn, pt as buildGraph, q as TresCanvasProps, qt as TresVector2, r as plugin, rn as useTresContext, rt as TresCustomRendererOptions, s as isTresInstance, sn as TresRenderer, st as useTres, t as TresOptions, tn as TresContext, tt as logMessage, u as isVectorLike, un as UseRendererOptions, ut as useTresContextProvider, v as isGroup, vn as TresLoader, vt as DisposeType, w as isNodeMaterial, wt as NonFunctionKeys, x as isMaterial, xn as useLoader, xt as LocalState, y as isLayers, yn as TresLoaderOptions, yt as ElementProps, z as DevtoolsSubscriber, zt as TresInstance } from "./index-CbIRI9tI.js";
+export { Args, AssetLoadData, AttachFnType, AttachType, ConstructorRepresentation, DevtoolsMessage, DevtoolsMessageType, DevtoolsMessenger, DevtoolsSubscriber, DisposeType, ElementProps, INJECTION_KEY, InstanceProps, LoaderMethods, LoaderProto, LocalState, LoopContext, MathType, Mutable, NonFunctionKeys, Overwrite, Properties, type RenderFunction, type RenderMode, type RendererOptions, ThreeElement, ThreeInstances, ThreeInstancesOf, TresCamera, _default as TresCanvas, _default$1 as TresCanvasContext, type TresCanvasEmits, type TresCanvasInstance, type TresCanvasProps, TresCatalogue, TresColor, TresColorArray, TresComponents, TresComponentsOf, type TresContext, TresContextWithClock, TresControl, type TresCustomRendererOptions, TresEuler, TresInstance, TresLayers, TresLoader, TresLoaderOptions, TresMaterial, TresObject, TresObject3D, TresObjectMap, TresOptions, TresPartialContext, TresPlugin, type TresPointerEvent, _default$2 as TresPortal, TresPrimitive, TresQuaternion, type TresRenderer, TresRendererError, TresRendererErrorCode, type TresRendererSetupContext, TresScene, TresTimer, TresVector2, TresVector3, TresVector4, UseCameraReturn, _default$3 as UseLoader, UseLoaderReturn, type UseRendererManagerReturn, type UseRendererOptions, VectorCoordinates, type VectorFlexibleParams, VueProps, WithMathProps, buildGraph, catalogue, createTimer, plugin as default, disposeObject3D as dispose, extend, isBufferGeometry, isCamera, isClassInstance, isColor, isColorRepresentation, isCopyable, isFog, isGroup, isLayers, isLight, isMaterial, isMesh, isNode, isNodeMaterial, isObject3D, isOrthographicCamera, isPerspectiveCamera, isProd, isScene, isTresCamera, isTresInstance, isTresObject, isTresPrimitive, isVectorLike, isWebGLRenderer, isWebGPURenderer, logError, logMessage, logWarning, normalizeColor, normalizeVectorFlexibleParam, registerTresDevtools, templateCompilerOptions, useCameraManager, useGraph, useLoader, useLoop, useRendererManager, useTres, useTresContext, useTresContextProvider, vDistanceTo, vLightHelper, vLog };