@thatopen/components 2.0.11 → 2.0.12

package/dist/core/Clipper/index.d.ts

@@ -4,7 +4,7 @@ import { SimplePlane } from "./src";
 import { Components } from "../Components";
 export * from "./src";
 /**
- * A lightweight component to easily create and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
+ * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
  *
  * @param components - the instance of {@link Components} used.
  * E.g. {@link SimplePlane}.

package/dist/core/Clipper/src/simple-plane.d.ts

@@ -2,7 +2,7 @@ import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
 /**
- * Each of the planes created by the clipper.
+ * Each of the clipping planes created by the clipper.
  */
 export declare class SimplePlane implements Disposable, Hideable {
     /** Event that fires when the user starts dragging a clipping plane. */
@@ -61,24 +61,24 @@ export declare class SimplePlane implements Disposable, Hideable {
     /** Sets the size of the clipping plane representation. */
     set size(size: number);
     /**
-   * Getter for the helper object of the clipping plane.
-   * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
-   * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
-   *
-   * @returns {THREE.Object3D} The helper object of the clipping plane.
-   */
+     * Getter for the helper object of the clipping plane.
+     * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
+     * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
+     *
+     * @returns {THREE.Object3D} The helper object of the clipping plane.
+     */
     get helper(): THREE.Object3D<THREE.Object3DEventMap>;
     constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
     /**
-   * Sets the clipping plane's normal and origin from the given normal and point.
-   * This method resets the clipping plane's state, updates the normal and origin,
-   * and positions the helper object accordingly.
-   *
-   * @param normal - The new normal vector for the clipping plane.
-   * @param point - The new origin point for the clipping plane.
-   *
-   * @returns {void}
-   */
+     * Sets the clipping plane's normal and origin from the given normal and point.
+     * This method resets the clipping plane's state, updates the normal and origin,
+     * and positions the helper object accordingly.
+     *
+     * @param normal - The new normal vector for the clipping plane.
+     * @param point - The new origin point for the clipping plane.
+     *
+     * @returns {void}
+     */
     setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
     /** {@link Updateable.update} */
     update: () => void;

package/dist/core/Components/index.d.ts

@@ -1,12 +1,12 @@
 import { Component, Disposable, Event } from "../Types";
 /**
- * The entry point of the Components library. It can create and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
+ * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
  */
 export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.0.11";
+    static readonly release = "2.0.12";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**

package/dist/core/Cullers/index.d.ts

@@ -3,7 +3,7 @@ import { MeshCullerRenderer, CullerRendererSettings } from "./src";
 import { Component, Event, Disposable, World } from "../Types";
 export * from "./src";
 /**
- * A component that manages and provides culling functionality for meshes in a 3D scene.
+ * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
  */
 export declare class Cullers extends Component implements Disposable {
     /**
@@ -12,8 +12,8 @@ export declare class Cullers extends Component implements Disposable {
      */
     static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
     /**
-   * An event that is triggered when the Cullers component is disposed.
-   */
+     * An event that is triggered when the Cullers component is disposed.
+     */
     readonly onDisposed: Event<unknown>;
     private _enabled;
     /**

package/dist/core/Cullers/src/culler-renderer.d.ts

@@ -2,7 +2,7 @@ import * as THREE from "three";
 import { Components } from "../../Components";
 import { AsyncEvent, Event, World } from "../../Types";
 /**
- * Interface for settings to configure the CullerRenderer.
+ * Settings to configure the CullerRenderer.
  */
 export interface CullerRendererSettings {
     /**

package/dist/core/Cullers/src/mesh-culler-renderer.d.ts

@@ -3,7 +3,7 @@ import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
 import { Event, World, Disposable } from "../../Types";
 /**
- * A renderer to determine a mesh visibility on screen.
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
 export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
@@ -45,11 +45,11 @@ export declare class MeshCullerRenderer extends CullerRenderer implements Dispos
      */
     add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-   * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-   * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-   * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-   * @returns {void}
-   */
+     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
     remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     private handleWorkerMessage;
     private getAvailableMaterial;

package/dist/core/Disposer/index.d.ts

@@ -2,7 +2,7 @@ import * as THREE from "three";
 import { Components } from "../Components";
 import { Component } from "../Types";
 /**
- * A tool to safely remove meshes and geometries from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
  */
 export declare class Disposer extends Component {
     private _disposedComponents;

package/dist/core/Grids/index.d.ts

@@ -1,8 +1,9 @@
 import { Component, Disposable, World, Event } from "../Types";
 import { GridConfig, SimpleGrid } from "./src";
 import { Components } from "../Components";
+export * from "./src";
 /**
- * A component that manages and provides access to multiple grid instances. Each grid is associated with a unique world.
+ * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
  */
 export declare class Grids extends Component implements Disposable {
     /**
@@ -24,14 +25,14 @@ export declare class Grids extends Component implements Disposable {
     enabled: boolean;
     constructor(components: Components);
     /**
-   * Creates a new grid for the given world.
-   * Throws an error if a grid already exists for the world.
-   *
-   * @param world - The world to create the grid for.
-   * @returns The newly created grid.
-   *
-   * @throws Will throw an error if a grid already exists for the given world.
-   */
+     * Creates a new grid for the given world.
+     * Throws an error if a grid already exists for the world.
+     *
+     * @param world - The world to create the grid for.
+     * @returns The newly created grid.
+     *
+     * @throws Will throw an error if a grid already exists for the given world.
+     */
     create(world: World): SimpleGrid;
     /**
      * Deletes the grid associated with the given world.

package/dist/core/Grids/src/simple-grid.d.ts

@@ -1,17 +1,29 @@
 import * as THREE from "three";
 import { Hideable, Event, World, Disposable } from "../../Types";
 import { Components } from "../../Components";
+/**
+ * Configuration interface for the {@link SimpleGrid} class.
+ */
 export interface GridConfig {
+    /**
+     * The color of the grid lines.
+     */
     color: THREE.Color;
+    /**
+     * The size of the primary grid lines.
+     */
     size1: number;
+    /**
+     * The size of the secondary grid lines.
+     */
     size2: number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
     distance: number;
 }
 /**
- * An infinite grid. Created by
- * [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper)
- * and translated to typescript by
- * [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
  */
 export declare class SimpleGrid implements Hideable, Disposable {
     /** {@link Disposable.onDisposed} */

package/dist/core/MiniMap/index.d.ts

@@ -1,14 +1,15 @@
 import { MiniMap } from "./src";
 import { Component, Updateable, World, Event, Disposable } from "../Types";
 import { Components } from "../Components";
+export * from "./src";
 /**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID.
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
  */
 export declare class MiniMaps extends Component implements Updateable, Disposable {
     /**
-   * A unique identifier for the component.
-   * This UUID is used to register the component within the Components system.
-   */
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
     static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
     /** {@link Updateable.onAfterUpdate} */
     readonly onAfterUpdate: Event<unknown>;
@@ -19,26 +20,26 @@ export declare class MiniMaps extends Component implements Updateable, Disposabl
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-   * A collection of {@link MiniMap} instances, each associated with a unique world ID.
-   */
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+     */
     list: Map<string, MiniMap>;
     constructor(components: Components);
     /**
-   * Creates a new {@link MiniMap} instance associated with the given world.
-   * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
-   *
-   * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-   * @returns The newly created {@link MiniMap} instance.
-   * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
-   */
+     * Creates a new {@link MiniMap} instance associated with the given world.
+     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
+     *
+     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
+     * @returns The newly created {@link MiniMap} instance.
+     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
+     */
     create(world: World): MiniMap;
     /**
-   * Deletes a {@link MiniMap} instance associated with the given world ID.
-   * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
-   *
-   * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-   * @returns {void}
-   */
+     * Deletes a {@link MiniMap} instance associated with the given world ID.
+     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
+     *
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
+     * @returns {void}
+     */
     delete(id: string): void;
     /** {@link Disposable.dispose} */
     dispose(): void;

package/dist/core/MiniMap/src/index.d.ts

@@ -1,7 +1,7 @@
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
- * A class representing a 2D minimap in a 3D world.
+ * A class representing a 2D minimap of a 3D world.
  */
 export declare class MiniMap implements Resizeable, Updateable, Disposable {
     /** {@link Disposable.onDisposed} */
@@ -52,27 +52,27 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     private _tempTarget;
     private readonly down;
     /**
-   * Gets or sets whether the minimap rotation is locked.
-   * When rotation is locked, the minimap will always face the same direction as the camera.
-   */
+     * Gets or sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     */
     get lockRotation(): boolean;
     /**
-   * Sets whether the minimap rotation is locked.
-   * When rotation is locked, the minimap will always face the same direction as the camera.
-   * @param active - If `true`, rotation is locked. If `false`, rotation is not locked.
-   */
+     * Sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * @param active - If `true`, rotation is locked. If `false`, rotation is not locked.
+     */
     set lockRotation(active: boolean);
     /**
-   * Gets the current zoom level of the minimap.
-   * The zoom level determines how much of the world is visible on the minimap.
-   * @returns The current zoom level of the minimap.
-   */
+     * Gets the current zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @returns The current zoom level of the minimap.
+     */
     get zoom(): number;
     /**
-   * Sets the zoom level of the minimap.
-   * The zoom level determines how much of the world is visible on the minimap.
-   * @param value - The new zoom level of the minimap.
-   */
+     * Sets the zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @param value - The new zoom level of the minimap.
+     */
     set zoom(value: number);
     constructor(world: World);
     /** {@link Disposable.dispose} */

package/dist/core/OrthoPerspectiveCamera/index.d.ts

@@ -4,7 +4,7 @@ import { SimpleCamera } from "..";
 import { NavigationMode, NavModeID, ProjectionManager } from "./src";
 export * from "./src";
 /**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to easily control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes.
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
  */
 export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
@@ -27,13 +27,13 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     protected _mode: NavigationMode | null;
     private previousSize;
     /**
-   * Getter for the current navigation mode.
-   * Throws an error if the mode is not found or the camera is not initialized.
-   *
-   * @returns {NavigationMode} The current navigation mode.
-   *
-   * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
-   */
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
+     *
+     * @returns {NavigationMode} The current navigation mode.
+     *
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     */
     get mode(): NavigationMode;
     constructor(components: Components);
     /** {@link Disposable.dispose} */

package/dist/core/Raycasters/index.d.ts

@@ -1,8 +1,9 @@
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
+export * from "./src";
 /**
- * A component that manages raycasters for different worlds. It uses a Map to store raycasters for each world, and automatically disposes them when the world is disposed.
+ * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
  */
 export declare class Raycasters extends Component implements Disposable {
     /**

package/dist/core/Raycasters/src/mouse.d.ts

@@ -1,10 +1,7 @@
 import * as THREE from "three";
 import { Disposable, Event } from "../../Types";
 /**
- * A helper to easily get the real position of the mouse in the Three.js canvas
- * to work with tools like the
- * [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has
- * been transformed through CSS or doesn't occupy the whole screen.
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
  */
 export declare class Mouse implements Disposable {
     dom: HTMLCanvasElement;

package/dist/core/Raycasters/src/simple-raycaster.d.ts

@@ -3,9 +3,7 @@ import { Components } from "../../Components";
 import { Event, World, Disposable } from "../../Types";
 import { Mouse } from "./mouse";
 /**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster)
- * that allows to easily get items from the scene using the mouse and touch
- * events.
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
  */
 export declare class SimpleRaycaster implements Disposable {
     /** {@link Component.enabled} */
@@ -40,14 +38,14 @@ export declare class SimpleRaycaster implements Disposable {
      */
     castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
     /**
-   * Casts a ray from a given origin in a given direction and returns the first item found.
-   * This method also takes into account the clipping planes used by the renderer.
-   *
-   * @param origin - The origin of the ray.
-   * @param direction - The direction of the ray.
-   * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-   * @returns The first intersection found or `null` if no intersection was found.
-   */
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or `null` if no intersection was found.
+     */
     castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
     private intersect;
     private filterClippingPlanes;

package/dist/core/Types/src/base-camera.d.ts

@@ -3,7 +3,7 @@ import CameraControls from "camera-controls";
 import { BaseWorldItem } from "./base-world-item";
 import { CameraControllable } from "./interfaces";
 /**
- * Abstract class representing a camera in the 3D world. All cameras should use this class as a base.
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
  */
 export declare abstract class BaseCamera extends BaseWorldItem {
     /**

package/dist/core/Types/src/base-renderer.d.ts

@@ -40,26 +40,26 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
      */
     clippingPlanes: THREE.Plane[];
     /**
-   * Updates the clipping planes and triggers the `onClippingPlanesUpdated` event.
-   *
-   * @remarks
-   * This method is typically called when there is a change to the list of clipping planes
-   * used by the active renderer.
-   */
+     * Updates the clipping planes and triggers the `onClippingPlanesUpdated` event.
+     *
+     * @remarks
+     * This method is typically called when there is a change to the list of clipping planes
+     * used by the active renderer.
+     */
     updateClippingPlanes(): void;
     /**
-   * Sets or removes a clipping plane from the renderer.
-   *
-   * @param active - A boolean indicating whether the clipping plane should be active or not.
-   * @param plane - The clipping plane to be added or removed.
-   * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to `false`.
-   *
-   * @remarks
-   * This method adds or removes a clipping plane from the `clippingPlanes` array.
-   * If `active` is `true` and the plane is not already in the array, it is added.
-   * If `active` is `false` and the plane is in the array, it is removed.
-   * The `three.clippingPlanes` property is then updated to reflect the current state of the `clippingPlanes` array,
-   * excluding any planes marked as local.
-   */
+     * Sets or removes a clipping plane from the renderer.
+     *
+     * @param active - A boolean indicating whether the clipping plane should be active or not.
+     * @param plane - The clipping plane to be added or removed.
+     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to `false`.
+     *
+     * @remarks
+     * This method adds or removes a clipping plane from the `clippingPlanes` array.
+     * If `active` is `true` and the plane is not already in the array, it is added.
+     * If `active` is `false` and the plane is in the array, it is removed.
+     * The `three.clippingPlanes` property is then updated to reflect the current state of the `clippingPlanes` array,
+     * excluding any planes marked as local.
+     */
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }

package/dist/core/Types/src/base-scene.d.ts

@@ -10,9 +10,9 @@ export declare abstract class BaseScene extends BaseWorldItem implements Disposa
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     /**
-    * Abstract property representing the three.js object associated with this scene.
-    * It should be implemented by subclasses.
-    */
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
+     */
     abstract three: THREE.Object3D;
     protected constructor(components: Components);
     /** {@link Disposable.dispose} */

package/dist/core/Worlds/index.d.ts

@@ -3,7 +3,7 @@ import { Components } from "../Components";
 import { SimpleWorld } from "./src";
 export * from "./src";
 /**
- * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds.
+ * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
  */
 export declare class Worlds extends Component implements Updateable, Disposable {
     /**
@@ -46,22 +46,22 @@ export declare class Worlds extends Component implements Updateable, Disposable
      */
     create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
     /**
-   * Deletes a world from the list of worlds.
-   *
-   * @param {World} world - The world to be deleted.
-   *
-   * @throws {Error} - Throws an error if the provided world is not found in the list.
-   *
-   * @returns {void}
-   */
+     * Deletes a world from the list of worlds.
+     *
+     * @param {World} world - The world to be deleted.
+     *
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     *
+     * @returns {void}
+     */
     delete(world: World): void;
     /**
-   * Disposes of the Worlds component and all its managed worlds.
-   * This method sets the enabled flag to false, disposes of all worlds, clears the list,
-   * and triggers the onDisposed event.
-   *
-   * @returns {void}
-   */
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
+     *
+     * @returns {void}
+     */
     dispose(): void;
     /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;

package/dist/core/Worlds/src/simple-camera.d.ts

@@ -3,7 +3,7 @@ import CameraControls from "camera-controls";
 import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
 /**
- * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to easily control the camera in 2D and 3D. Check out it's API to find out what features it offers.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
  */
 export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
     /** {@link Updateable.onBeforeUpdate} */

package/dist/core/Worlds/src/simple-scene.d.ts

@@ -29,9 +29,9 @@ export declare class SimpleScene extends BaseScene implements Configurable<{}> {
     /** {@link Configurable.onSetup} */
     readonly onSetup: Event<SimpleScene>;
     /**
-   * Configuration interface for the {@link SimpleScene}.
-   * Defines properties for directional and ambient lights.
-   */
+     * Configuration interface for the {@link SimpleScene}.
+     * Defines properties for directional and ambient lights.
+     */
     config: Required<SimpleSceneConfig>;
     constructor(components: Components);
     /** {@link Configurable.setup} */