@tresjs/core 5.9.1 → 5.9.3

package/dist/tres.d.ts

@@ -1,31 +1,28 @@
 /**
   * name: @tresjs/core
-  * version: v5.9.1
+  * version: v5.9.3
   * (c) 2026
   * description: Declarative ThreeJS using Vue Components
   * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
   */
-import * as vue20 from "vue";
 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 * as _vueuse_core0 from "@vueuse/core";
 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
-interface LoaderMethods {
+export interface LoaderMethods {
   setDRACOLoader: (dracoLoader: any) => void;
   setMeshoptDecoder: (meshoptDecoder: any) => void;
   setKTX2Loader: (ktx2Loader: any) => void;
 }
-type TresLoader<T> = Loader & Partial<LoaderMethods> & {
+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>;
 };
-type LoaderProto<T> = new (manager?: LoadingManager) => TresLoader<T>;
-interface TresLoaderOptions<T, Shallow extends boolean> {
+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;
@@ -37,7 +34,7 @@ interface TresLoaderOptions<T, Shallow extends boolean> {
  * @template Shallow - Whether to use shallow reactivity for better performance
  * @extends {UseAsyncStateReturn<T, [string], Shallow>} - Extends VueUse's useAsyncState return type
  */
-type UseLoaderReturn<T, Shallow extends boolean> = UseAsyncStateReturn<T, [string], Shallow> & {
+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
@@ -62,7 +59,7 @@ type UseLoaderReturn<T, Shallow extends boolean> = UseAsyncStateReturn<T, [strin
  * @param options - Optional configuration for the loader
  * @returns UseAsyncState composable with the loaded model
  */
-declare function useLoader<T, Shallow extends boolean = false>(Loader: LoaderProto<T>, path: MaybeRef<string>, options?: TresLoaderOptions<T, Shallow>): UseLoaderReturn<T, Shallow>;
+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 {
@@ -82,7 +79,7 @@ interface SizesType {
 /**
  * Interface for the return value of the useCamera composable
  */
-interface UseCameraReturn {
+export interface UseCameraReturn {
   activeCamera: ComputedRef<TresCamera>;
   /**
    * The list of cameras
@@ -117,13 +114,11 @@ interface UseCameraParams {
  * @param params.sizes - The sizes object containing window dimensions
  * @returns The camera management functions and state
  */
-declare const useCameraManager: ({
-  sizes
-}: UseCameraParams) => UseCameraReturn;
+export declare const useCameraManager: ({ sizes }: UseCameraParams) => UseCameraReturn;
 //#endregion
 //#region src/utils/error.d.ts
-type TresRendererErrorCode = 'INITIALIZATION_FAILED';
-declare class TresRendererError extends Error {
+export type TresRendererErrorCode = 'INITIALIZATION_FAILED';
+export declare class TresRendererError extends Error {
   readonly code: TresRendererErrorCode;
   readonly name = "TresRendererError";
   constructor(message: string, code: TresRendererErrorCode, options?: ErrorOptions);
@@ -135,10 +130,10 @@ declare class TresRendererError extends Error {
  * 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
  */
-type RenderMode = 'always' | 'on-demand' | 'manual';
-type RenderFunction = (notifySuccess: () => void) => void;
-type TresRenderer = WebGLRenderer | Renderer;
-interface RendererOptions {
+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
@@ -181,22 +176,22 @@ interface RendererOptions {
   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.
+   * 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
-     */
+   * 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.
@@ -247,10 +242,10 @@ interface RendererOptions {
    * Type of shadow map to use for shadow calculations
    * - `BasicShadowMap`: Basic shadow map.
    * - `PCFShadowMap`: Percentage-Closer Filtering shadow map.
-   * - `PCFSoftShadowMap`: Deprecated on WebGL, three falls back to `PCFShadowMap`. Still supported on WebGPU.
+   * - `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 WebGL, PCFSoftShadowMap on WebGPU (Opinionated default by TresJS)
+   * @default PCFShadowMap. On WebGPU before r186, PCFSoftShadowMap (Opinionated default by TresJS)
    */
   shadowMapType?: ShadowMapType;
   /**
@@ -287,63 +282,47 @@ interface RendererOptions {
    */
   renderer?: (ctx: TresRendererSetupContext) => TresRenderer;
 }
-interface TresRendererSetupContext {
+export interface TresRendererSetupContext {
   sizes: SizesType;
   scene: ShallowRef<TresScene>;
   camera: UseCameraReturn;
   canvas: MaybeRef<HTMLCanvasElement>;
 }
-interface UseRendererOptions {
+export interface UseRendererOptions {
   scene: ShallowRef<TresScene>;
   canvas: MaybeRef<HTMLCanvasElement>;
   options: Reactive<RendererOptions>;
   fpsLimit?: MaybeRefOrGetter<number>;
   contextParts: Pick<TresContext, 'sizes' | 'camera'>;
 }
-declare function useRendererManager({
-  scene,
-  canvas,
-  options,
-  fpsLimit,
-  contextParts: {
-    sizes,
-    camera
-  }
-}: UseRendererOptions): {
+export declare function useRendererManager({ scene, canvas, options, fpsLimit, contextParts: { sizes, camera } }: UseRendererOptions): {
   loop: {
     start: () => void;
     stop: () => void;
     isActive: Readonly<ShallowRef<boolean>>;
-    onBeforeLoop: _vueuse_core0.EventHookOn<RafLoopContext>;
-    onLoop: _vueuse_core0.EventHookOn<RafLoopContext>;
+    onBeforeLoop: import("@vueuse/core").EventHookOn<RafLoopContext>;
+    onLoop: import("@vueuse/core").EventHookOn<RafLoopContext>;
   };
   instance: TresRenderer;
   advance: () => void;
-  onReady: _vueuse_core0.EventHookOn<TresRenderer>;
-  onRender: _vueuse_core0.EventHookOn<TresRenderer>;
-  onError: _vueuse_core0.EventHookOn<TresRendererError>;
+  onReady: import("@vueuse/core").EventHookOn<TresRenderer>;
+  onRender: import("@vueuse/core").EventHookOn<TresRenderer>;
+  onError: import("@vueuse/core").EventHookOn<TresRendererError>;
   invalidate: (amountOfFramesToInvalidate?: number) => void;
-  canBeInvalidated: vue20.ComputedRef<boolean>;
+  canBeInvalidated: import("vue").ComputedRef<boolean>;
   mode: "always" | "on-demand" | "manual" | undefined;
   replaceRenderFunction: (fn: RenderFunction) => void;
-  isInitialized: vue20.Ref<boolean, boolean>;
-  error: vue20.Ref<TresRendererError | null, TresRendererError | null>;
+  isInitialized: import("vue").Ref<boolean, boolean>;
+  error: import("vue").Ref<TresRendererError | null, TresRendererError | null>;
 };
-type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;
+export type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;
 //#endregion
 //#region src/composables/useEventManager/index.d.ts
-declare function useEventManager({
-  canvas,
-  contextParts: {
-    scene,
-    camera,
-    renderer
-  }
-}: {
+declare function useEventManager({ canvas, contextParts: { scene, camera, renderer } }: {
   canvas: MaybeRef<HTMLCanvasElement>;
   contextParts: Pick<TresContext, 'scene' | 'camera' | 'renderer'>;
 }): {
-  onPointerMissed: _vueuse_core0.EventHookOn<TresPointerEvent & Event<"click", Object3D<Object3DEventMap & PointerEventsMap>>>;
+  onPointerMissed: import("@vueuse/core").EventHookOn<TresPointerEvent & Event<"click", Object3D<Object3DEventMap & PointerEventsMap>>>;
 };
 //#endregion
 //#region src/composables/useTresContextProvider/index.d.ts
@@ -365,7 +344,7 @@ interface TresContext {
   isWebGPU: ComputedRef<boolean>;
   events: ReturnType<typeof useEventManager>;
 }
-declare const INJECTION_KEY = "useTres";
+export declare const INJECTION_KEY = "useTres";
 declare const useTresContextProvider: (args_0: {
   scene: TresScene;
   canvas: MaybeRef<HTMLCanvasElement>;
@@ -380,29 +359,29 @@ declare const supportedPointerEvents: readonly ["onClick", "onContextmenu", "onP
 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 };
+type PointerEventHandlers = { [key in SupportedVuePointerEvent]: (event: TresPointerEvent) => void; };
 //#endregion
 //#region src/types/index.d.ts
-type AttachFnType = (parent: any, self: TresInstance) => () => void;
-type AttachType = string | AttachFnType;
-type DisposeType = ((self: TresInstance) => void) | boolean | 'default' | null;
-type ConstructorRepresentation = new (...args: any[]) => any;
-type NonFunctionKeys<P> = { [K in keyof P]-?: P[K] extends ((...args: any[]) => any) ? never : K }[keyof P];
-type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O;
-type Properties<T> = Pick<T, NonFunctionKeys<T>>;
-type Mutable<P> = { [K in keyof P]: P[K] | Readonly<P[K]> };
-type Args<T> = T extends ConstructorRepresentation ? ConstructorParameters<T> : any[];
-interface TresCatalogue {
+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;
 }
-type TresCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+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.
  */
-interface InstanceProps<T = any, P = any> {
+export interface InstanceProps<T = any, P = any> {
   args?: Args<P>;
   object?: T;
   visible?: boolean;
@@ -414,7 +393,7 @@ interface TresBaseObject {
   dispose?: () => void;
   [prop: string]: any;
 }
-interface LocalState {
+export interface LocalState {
   type: string;
   root: TresContext;
   memoizedProps: {
@@ -427,11 +406,11 @@ interface LocalState {
   attach?: AttachType;
   previousAttach: any;
 }
-interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
+export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
   geometry?: THREE.BufferGeometry & TresBaseObject;
   material?: THREE.Material & TresBaseObject;
 }
-type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
+export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
   __tres?: LocalState;
 };
 /**
@@ -439,15 +418,15 @@ type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.
  * This provides better TypeScript intellisense and type checking
  * when accessing specific material properties
  */
-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;
-type TresInstance = TresObject & {
+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;
 };
-type TresPrimitive = TresInstance & {
+export type TresPrimitive = TresInstance & {
   object: TresInstance;
   isPrimitive: true;
 };
-interface TresScene extends THREE.Scene {
+export interface TresScene extends THREE.Scene {
   __tres: {
     root: TresContext;
     objects: TresObject[];
@@ -461,48 +440,48 @@ interface VectorRepresentation extends MathRepresentation {
   setScalar(s: number): any;
 }
 type MathTypes = MathRepresentation | THREE.Euler | THREE.Color;
-interface VectorCoordinates {
+export interface VectorCoordinates {
   x: number;
   y: number;
   z: number;
 }
-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']>;
+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];
-type TresVector2 = VectorLike$1<THREE.Vector2>;
-type TresVector3 = VectorLike$1<THREE.Vector3>;
-type TresVector4 = VectorLike$1<THREE.Vector4>;
-type TresColor = ConstructorParameters<typeof THREE.Color> | THREE.Color | number | string;
-type TresColorArray = typeof THREE.Color | [color: THREE.ColorRepresentation];
-type TresLayers = THREE.Layers | Parameters<THREE.Layers['set']>[0];
-type TresQuaternion = THREE.Quaternion | Parameters<THREE.Quaternion['set']>;
-type TresEuler = THREE.Euler;
-type TresControl = THREE.EventDispatcher & {
+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;
 };
-type TresContextWithClock = TresContext & {
+export type TresContextWithClock = TresContext & {
   delta: number;
   elapsed: number;
 };
-type WithMathProps<P> = { [K in keyof P]: P[K] extends MathTypes ? MathType<P[K]> : P[K] };
+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;
-interface VueProps {
+export interface VueProps {
   children?: VNode[];
   ref?: VNodeRef;
   key?: string | number | symbol;
 }
-type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<Overwrite<P, WithMathProps<P> & VueProps & EventProps<P>>>;
-type ThreeElement<T extends ConstructorRepresentation> = Mutable<Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>>;
+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 };
-interface ThreeInstances extends ThreeInstancesImpl {
+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;
   };
 }
-type TresComponents = { [K in keyof ThreeInstances as `Tres${Capitalize<string & K>}`]: DefineComponent<ThreeInstances[K]> };
+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>;
@@ -510,7 +489,7 @@ declare module 'vue' {
 }
 //#endregion
 //#region src/utils/graph.d.ts
-interface TresObjectMap {
+export interface TresObjectMap {
   nodes: {
     [name: string]: TresObject;
   };
@@ -522,11 +501,11 @@ interface TresObjectMap {
   };
   scene?: Scene;
 }
-declare function buildGraph(object: Object3D | TresObject): TresObjectMap;
+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: vue20.PublicProps & __VLS_PrettifyLocal<{
+  props: import("vue").PublicProps & __VLS_PrettifyLocal<{
     /**
      * The THREE.js loader to use
      */
@@ -550,20 +529,20 @@ declare const __VLS_export$3: <T extends TresObjectMap>(__VLS_props: NonNullable
   attrs: any;
   slots: {
     default?: (props: {
-      state: vue20.UnwrapRef<T>;
+      state: T;
       isLoading: boolean;
       error: unknown;
     }) => any;
   };
   emit: ((evt: "error", error: unknown) => void) & ((evt: "loaded", result: T) => void);
-}>) => vue20.VNode & {
-  __ctx?: Awaited<typeof __VLS_setup>;
+}>) => 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] }) & {};
+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
-declare const useGraph: (object: MaybeRef<TresObject | undefined>) => vue20.ComputedRef<TresObjectMap | undefined>;
+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];
@@ -572,7 +551,7 @@ type PriorityEventHookOn<T> = (fn: Callback<T>, priority?: number) => {
 };
 //#endregion
 //#region src/composables/useTres/index.d.ts
-interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
+export interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
   /**
    * The renderer instance
    *
@@ -604,17 +583,17 @@ interface TresPartialContext extends Omit<TresContext, 'renderer' | 'camera'> {
    */
   advance: () => void;
 }
-declare function useTres(): TresPartialContext;
+export declare function useTres(): TresPartialContext;
 //#endregion
 //#region src/composables/useLoop/index.d.ts
-type LoopContext = RafLoopContext & TresPartialContext;
+export type LoopContext = RafLoopContext & TresPartialContext;
 /**
  * Composable that provides control over the render loop and animation lifecycle.
  */
-declare const useLoop: () => {
+export declare const useLoop: () => {
   stop: () => void;
   start: () => void;
-  isActive: Readonly<vue20.ShallowRef<boolean>>;
+  isActive: Readonly<import("vue").ShallowRef<boolean>>;
   onBeforeRender: PriorityEventHookOn<LoopContext>;
   onRender: PriorityEventHookOn<LoopContext>;
   render: (fn: RenderFunction) => void;
@@ -630,7 +609,7 @@ interface TresCustomRendererOptions {
  * Logger utility for TresJS
  * @module logger
  */
-declare const isProd: boolean;
+export declare const isProd: boolean;
 type OneOrMore<T> = {
   0: T;
 } & Array<T>;
@@ -638,18 +617,18 @@ type OneOrMore<T> = {
  * Logs an error message with the TresJS prefix
  * @param args - Arguments to log
  */
-declare function logError(...args: OneOrMore<any>): void;
+export declare function logError(...args: OneOrMore<any>): void;
 /**
  * Logs a warning message with the TresJS prefix
  * @param args - Arguments to log
  */
-declare function logWarning(...args: OneOrMore<any>): void;
+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
  */
-declare function logMessage(name: string, value: any): void;
+export declare function logMessage(name: string, value: any): void;
 //#endregion
 //#region src/utils/index.d.ts
 declare function disposeObject3D(object: TresObject): void;
@@ -665,8 +644,8 @@ interface Vector3PropInterface extends Vector2PropInterface {
   z?: number;
 }
 type VectorFlexibleParams = Vector3 | number[] | Vector3PropInterface | number;
-declare function normalizeVectorFlexibleParam(value: VectorFlexibleParams): Array<number>;
-declare function normalizeColor(value: Color | Array<number> | string | number | ColorRepresentation): Color;
+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: {
@@ -714,17 +693,17 @@ type ContextEmits = {
   render: [context: TresContext];
   beforeLoop: [context: TresContextWithClock];
   loop: [context: TresContextWithClock];
-} & { [key in TresPointerEventName]: [event: TresPointerEvent] };
+} & { [key in TresPointerEventName]: [event: TresPointerEvent]; };
 type __VLS_Props$1 = ContextProps & {
   canvas: HTMLCanvasElement;
 };
 type __VLS_Slots$2 = {
   default: () => any;
 };
-declare const __VLS_base$2: vue20.DefineComponent<__VLS_Props$1, {
-  context: vue20.ShallowRef<TresContext, TresContext>;
+declare const __VLS_base$2: import("vue").DefineComponent<__VLS_Props$1, {
+  context: import("vue").ShallowRef<TresContext, TresContext>;
   dispose: () => void;
-}, {}, {}, {}, vue20.ComponentOptionsMixin, vue20.ComponentOptionsMixin, {
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
   render: (context: TresContext) => any;
   click: (event: TresPointerEvent) => any;
   contextmenu: (event: TresPointerEvent) => any;
@@ -744,7 +723,7 @@ declare const __VLS_base$2: vue20.DefineComponent<__VLS_Props$1, {
   pointermissed: (event: TresPointerEvent) => any;
   beforeLoop: (context: TresContextWithClock) => any;
   loop: (context: TresContextWithClock) => any;
-}, string, vue20.PublicProps, Readonly<__VLS_Props$1> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_Props$1> & Readonly<{
   onRender?: ((context: TresContext) => any) | undefined;
   onClick?: ((event: TresPointerEvent) => any) | undefined;
   onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
@@ -764,7 +743,7 @@ declare const __VLS_base$2: vue20.DefineComponent<__VLS_Props$1, {
   onPointermissed?: ((event: TresPointerEvent) => any) | undefined;
   onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
   onLoop?: ((context: TresContextWithClock) => any) | undefined;
-}>, {}, {}, {}, {}, string, vue20.ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, 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 & {
@@ -783,7 +762,7 @@ interface TresCanvasInstance {
 type __VLS_Slots$1 = {
   default: () => any;
 };
-declare const __VLS_base$1: vue20.DefineComponent<ContextProps, TresCanvasInstance, {}, {}, {}, vue20.ComponentOptionsMixin, vue20.ComponentOptionsMixin, {
+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;
@@ -803,7 +782,7 @@ declare const __VLS_base$1: vue20.DefineComponent<ContextProps, TresCanvasInstan
   pointermissed: (event: TresPointerEvent) => any;
   beforeLoop: (context: TresContextWithClock) => any;
   loop: (context: TresContextWithClock) => any;
-}, string, vue20.PublicProps, Readonly<ContextProps> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<ContextProps> & Readonly<{
   onRender?: ((context: TresContext) => any) | undefined;
   onClick?: ((event: TresPointerEvent) => any) | undefined;
   onContextmenu?: ((event: TresPointerEvent) => any) | undefined;
@@ -826,10 +805,10 @@ declare const __VLS_base$1: vue20.DefineComponent<ContextProps, TresCanvasInstan
 }>, {
   alpha: boolean;
   logarithmicDepthBuffer: boolean;
-  toneMapping: THREE.ToneMapping;
+  toneMapping: import("three").ToneMapping;
   depth: boolean;
   stencil: boolean;
-  clearColor: THREE.ColorRepresentation;
+  clearColor: import("three").ColorRepresentation;
   windowSize: boolean;
   enableProvideBridge: boolean;
   customRendererOptions: TresCustomRendererOptions;
@@ -838,10 +817,10 @@ declare const __VLS_base$1: vue20.DefineComponent<ContextProps, TresCanvasInstan
   failIfMajorPerformanceCaveat: boolean;
   clearAlpha: number;
   shadows: boolean;
-  shadowMapType: THREE.ShadowMapType;
+  shadowMapType: import("three").ShadowMapType;
   useLegacyLights: boolean;
   renderMode: "always" | "on-demand" | "manual";
-}, {}, {}, {}, string, vue20.ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, 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 & {
@@ -861,7 +840,7 @@ declare var __VLS_7: {};
 type __VLS_Slots = {} & {
   default?: (props: typeof __VLS_7) => any;
 };
-declare const __VLS_base: vue20.DefineComponent<__VLS_Props, {}, {}, {}, {}, vue20.ComponentOptionsMixin, vue20.ComponentOptionsMixin, {}, string, vue20.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, vue20.ComponentProvideOptions, false, {}, 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 & {
@@ -871,29 +850,29 @@ type __VLS_WithSlots<T, S> = T & {
 };
 //#endregion
 //#region src/core/catalogue.d.ts
-declare const catalogue: Ref<TresCatalogue>;
-declare const extend: (objects: any) => any;
+export declare const catalogue: Ref<TresCatalogue>;
+export declare const extend: (objects: any) => any;
 //#endregion
 //#region src/devtools/DevtoolsMessenger.d.ts
-type DevtoolsMessageType = 'performance' | 'context' | 'asset-load';
-interface AssetLoadData {
+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;
 }
-interface DevtoolsMessage<T = any> {
+export interface DevtoolsMessage<T = any> {
   type: DevtoolsMessageType;
   data: T;
   timestamp?: number;
 }
-type DevtoolsSubscriber = (message: DevtoolsMessage) => void;
+export type DevtoolsSubscriber = (message: DevtoolsMessage) => void;
 /**
  * Messenger class for communicating with Tres DevTools
  * This class will be attached to window.__TRES__DEVTOOLS__
  */
-declare class DevtoolsMessenger {
+export declare class DevtoolsMessenger {
   private subscribers;
   private messageQueue;
   private maxQueueSize;
@@ -930,30 +909,30 @@ declare class DevtoolsMessenger {
 }
 //#endregion
 //#region src/devtools/plugin.d.ts
-declare function registerTresDevtools(app: App, tres: TresContext): void;
+export declare function registerTresDevtools(app: App, tres: TresContext): void;
 //#endregion
 //#region src/directives/vDistanceTo.d.ts
-declare const vDistanceTo: {
+export declare const vDistanceTo: {
   updated: (el: TresObject, binding: Ref<TresObject>) => void;
   unmounted: (el: TresObject) => void;
 };
 //#endregion
 //#region src/directives/vLightHelper.d.ts
-declare const vLightHelper: {
+export declare const vLightHelper: {
   mounted: (el: TresObject) => void;
   updated: (el: TresObject) => void;
   unmounted: (el: TresObject) => void;
 };
 //#endregion
 //#region src/directives/vLog.d.ts
-declare const vLog: {
+export declare const vLog: {
   mounted: (el: TresObject, binding: {
     arg: string;
   }) => void;
 };
 //#endregion
 //#region src/utils/createTimer.d.ts
-interface TresTimer {
+export interface TresTimer {
   getDelta: () => number;
   getElapsed: () => number;
   update: () => void;
@@ -968,7 +947,7 @@ interface TresTimer {
  * - On older versions: uses `Clock` with `start`/`stop`.
  *
  */
-declare function createTimer(): TresTimer;
+export declare function createTimer(): TresTimer;
 //#endregion
 //#region src/utils/is/three.d.ts
 /**
@@ -986,7 +965,7 @@ declare function createTimer(): TresTimer;
  * }
  * ```
  */
-declare const isObject3D: (value: unknown) => value is Object3D<THREE.Object3DEventMap>;
+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
@@ -998,7 +977,7 @@ declare const isObject3D: (value: unknown) => value is Object3D<THREE.Object3DEv
  *   // TypeScript knows value is Mesh here
  *   value.geometry // OK
  */
-declare const isMesh: (value: unknown) => value is Mesh<BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, Material<THREE.MaterialEventMap> | Material<THREE.MaterialEventMap>[], THREE.Object3DEventMap>;
+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
@@ -1014,37 +993,37 @@ declare const isMesh: (value: unknown) => value is Mesh<BufferGeometry<THREE.Nor
  * }
  * ```
  */
-declare const isCamera: (value: unknown) => value is Camera;
+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
  */
-declare const isOrthographicCamera: (value: unknown) => value is OrthographicCamera;
+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
  */
-declare const isPerspectiveCamera: (value: unknown) => value is PerspectiveCamera;
+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
  */
-declare const isColor: (value: unknown) => value is Color;
+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
  */
-declare const isColorRepresentation: (value: unknown) => value is ColorRepresentation;
+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
  */
-declare const isLayers: (value: unknown) => value is Layers;
+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
@@ -1060,7 +1039,7 @@ declare const isLayers: (value: unknown) => value is Layers;
  * }
  * ```
  */
-declare const isBufferGeometry: (value: unknown) => value is BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+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
@@ -1076,7 +1055,7 @@ declare const isBufferGeometry: (value: unknown) => value is BufferGeometry<THRE
  * }
  * ```
  */
-declare const isMaterial: (value: unknown) => value is Material<THREE.MaterialEventMap>;
+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
@@ -1092,7 +1071,7 @@ declare const isMaterial: (value: unknown) => value is Material<THREE.MaterialEv
  * }
  * ```
  */
-declare const isLight: (value: unknown) => value is Light;
+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
@@ -1108,7 +1087,7 @@ declare const isLight: (value: unknown) => value is Light;
  * }
  * ```
  */
-declare const isFog: (value: unknown) => value is Fog;
+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
@@ -1124,36 +1103,36 @@ declare const isFog: (value: unknown) => value is Fog;
  * }
  * ```
  */
-declare const isScene: (value: unknown) => value is Scene<THREE.Object3DEventMap>;
+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
  * ```
  */
-declare const isGroup: (value: unknown) => value is Group<THREE.Object3DEventMap>;
+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;
 }
-declare const isVectorLike: (value: unknown) => value is VectorLike;
+export declare const isVectorLike: (value: unknown) => value is VectorLike;
 interface Copyable {
   copy: (...args: any[]) => void;
   constructor?: (...args: any[]) => any;
 }
-declare const isCopyable: (value: unknown) => value is Copyable;
+export declare const isCopyable: (value: unknown) => value is Copyable;
 interface ClassInstance {
   constructor?: (...args: any[]) => any;
 }
-declare const isClassInstance: (object: unknown) => object is ClassInstance;
+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
  */
-declare const isTresCamera: (value: unknown) => value is TresCamera;
+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
@@ -1170,7 +1149,7 @@ declare const isTresCamera: (value: unknown) => value is TresCamera;
  * 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.
  */
-declare const isTresObject: (value: unknown) => value is TresObject;
+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
@@ -1187,7 +1166,7 @@ declare const isTresObject: (value: unknown) => value is TresObject;
  * 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.
  */
-declare const isTresPrimitive: (value: unknown) => value is TresPrimitive;
+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
@@ -1201,7 +1180,7 @@ declare const isTresPrimitive: (value: unknown) => value is TresPrimitive;
  * }
  * ```
  */
-declare const isTresInstance: (value: unknown) => value is TresInstance;
+export declare const isTresInstance: (value: unknown) => value is TresInstance;
 /**
  * Type guard to check if a value is a Three.js WebGPU `Renderer`.
  *
@@ -1220,25 +1199,25 @@ declare const isTresInstance: (value: unknown) => value is TresInstance;
  * }
  * ```
  */
-declare const isWebGPURenderer: (value: unknown) => value is Renderer;
+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}
  */
-declare const isWebGLRenderer: (value: unknown) => value is WebGLRenderer & {
+export declare const isWebGLRenderer: (value: unknown) => value is WebGLRenderer & {
   isWebGLRenderer: true;
 };
 //#endregion
 //#region src/index.d.ts
-interface TresOptions {
+export interface TresOptions {
   extends?: Record<string, unknown>;
 }
-interface TresPlugin {
+export interface TresPlugin {
   [key: string]: any;
   install: (app: App, options?: TresOptions) => void;
 }
 declare const plugin: TresPlugin;
 //#endregion
-export { Args, AssetLoadData, AttachFnType, AttachType, ConstructorRepresentation, DevtoolsMessage, DevtoolsMessageType, DevtoolsMessenger, DevtoolsSubscriber, DisposeType, ElementProps, INJECTION_KEY, InstanceProps, LoaderMethods, LoaderProto, LocalState, LoopContext, MathType, Mutable, NonFunctionKeys, Overwrite, Properties, RenderFunction, RenderMode, RendererOptions, ThreeElement, ThreeInstances, TresCamera, _default as TresCanvas, _default$1 as TresCanvasContext, type TresCanvasEmits, type TresCanvasInstance, type TresCanvasProps, TresCatalogue, TresColor, TresColorArray, TresComponents, 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, TresRenderer, TresRendererError, TresRendererErrorCode, TresRendererSetupContext, TresScene, TresTimer, TresVector2, TresVector3, TresVector4, UseCameraReturn, _default$3 as UseLoader, UseLoaderReturn, UseRendererManagerReturn, 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, 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 };
+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 };