@nativescript/canvas-three 2.0.0-webgpu.27 → 2.0.0-webgpu.29

package/three/src/extras/ImageUtils.d.ts

@@ -4,29 +4,27 @@
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ImageUtils.js | Source}
  */
 declare class ImageUtils {
-    /**
-     * Returns a data URI containing a representation of the given image.
-     * @param image The image object.
-     */
-    static getDataURL(
-        image: HTMLImageElement | HTMLCanvasElement | CanvasImageSource | ImageBitmap | ImageData,
-    ): string;
+	/**
+	 * Returns a data URI containing a representation of the given image.
+	 * @param image The image object.
+	 */
+	static getDataURL(image: HTMLImageElement | HTMLCanvasElement | CanvasImageSource | ImageBitmap | ImageData): string;
 
-    /**
-     * Converts the given sRGB image data to linear color space.
-     * @param image
-     */
-    static sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
+	/**
+	 * Converts the given sRGB image data to linear color space.
+	 * @param image
+	 */
+	static sRGBToLinear(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap): HTMLCanvasElement;
 
-    /**
-     * Converts the given sRGB image data to linear color space.
-     * @param image
-     */
-    static sRGBToLinear(image: ImageData): {
-        data: ImageData["data"];
-        width: ImageData["width"];
-        height: ImageData["height"];
-    };
+	/**
+	 * Converts the given sRGB image data to linear color space.
+	 * @param image
+	 */
+	static sRGBToLinear(image: ImageData): {
+		data: ImageData['data'];
+		width: ImageData['width'];
+		height: ImageData['height'];
+	};
 }
 
 export { ImageUtils };

package/three/src/extras/PMREMGenerator.d.ts

@@ -1,8 +1,8 @@
-import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
-import { WebGLRenderTarget } from "../renderers/WebGLRenderTarget.js";
-import { Scene } from "../scenes/Scene.js";
-import { CubeTexture } from "../textures/CubeTexture.js";
-import { Texture } from "../textures/Texture.js";
+import { WebGLRenderer } from '../renderers/WebGLRenderer.js';
+import { WebGLRenderTarget } from '../renderers/WebGLRenderTarget.js';
+import { Scene } from '../scenes/Scene.js';
+import { CubeTexture } from '../textures/CubeTexture.js';
+import { Texture } from '../textures/Texture.js';
 
 /**
  * This class generates a Prefiltered, Mipmapped Radiance Environment Map (PMREM) from a cubeMap environment texture.
@@ -29,54 +29,54 @@ import { Texture } from "../textures/Texture.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/PMREMGenerator.js | Source}
  */
 export class PMREMGenerator {
-    /**
-     * This constructor creates a new PMREMGenerator.
-     * @param renderer
-     */
-    constructor(renderer: WebGLRenderer);
+	/**
+	 * This constructor creates a new PMREMGenerator.
+	 * @param renderer
+	 */
+	constructor(renderer: WebGLRenderer);
 
-    /**
-     * Generates a PMREM from a supplied Scene, which can be faster than using an image if networking bandwidth is low
-     * @remarks
-     * Optional near and far planes ensure the scene is rendered in its entirety (the cubeCamera is placed at the origin).
-     * @param scene The given scene.
-     * @param sigma Specifies a blur radius in radians to be applied to the scene before PMREM generation. Default `0`.
-     * @param near The near plane value. Default `0.1`.
-     * @param far The far plane value. Default `100`.
-     */
-    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): WebGLRenderTarget;
+	/**
+	 * Generates a PMREM from a supplied Scene, which can be faster than using an image if networking bandwidth is low
+	 * @remarks
+	 * Optional near and far planes ensure the scene is rendered in its entirety (the cubeCamera is placed at the origin).
+	 * @param scene The given scene.
+	 * @param sigma Specifies a blur radius in radians to be applied to the scene before PMREM generation. Default `0`.
+	 * @param near The near plane value. Default `0.1`.
+	 * @param far The far plane value. Default `100`.
+	 */
+	fromScene(scene: Scene, sigma?: number, near?: number, far?: number): WebGLRenderTarget;
 
-    /**
-     * Generates a PMREM from an equirectangular texture, which can be either LDR or HDR. The ideal input image size is
-     * 1k (1024 x 512), as this matches best with the 256 x 256 cubemap output. The smallest supported equirectangular
-     * image size is 64 x 32.
-     */
-    fromEquirectangular(equirectangular: Texture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+	/**
+	 * Generates a PMREM from an equirectangular texture, which can be either LDR or HDR. The ideal input image size is
+	 * 1k (1024 x 512), as this matches best with the 256 x 256 cubemap output. The smallest supported equirectangular
+	 * image size is 64 x 32.
+	 */
+	fromEquirectangular(equirectangular: Texture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
 
-    /**
-     * Generates a PMREM from an cubemap texture, which can be either LDR or HDR. The ideal input cube size is
-     * 256 x 256, as this matches best with the 256 x 256 cubemap output. The smallest supported cube size is 16 x 16.
-     */
-    fromCubemap(cubemap: CubeTexture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
+	/**
+	 * Generates a PMREM from an cubemap texture, which can be either LDR or HDR. The ideal input cube size is
+	 * 256 x 256, as this matches best with the 256 x 256 cubemap output. The smallest supported cube size is 16 x 16.
+	 */
+	fromCubemap(cubemap: CubeTexture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
 
-    /**
-     * Pre-compiles the cubemap shader
-     * @remarks
-     * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
-     */
-    compileCubemapShader(): void;
+	/**
+	 * Pre-compiles the cubemap shader
+	 * @remarks
+	 * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
+	 */
+	compileCubemapShader(): void;
 
-    /**
-     * Pre-compiles the equirectangular shader
-     * @remarks
-     * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
-     */
-    compileEquirectangularShader(): void;
+	/**
+	 * Pre-compiles the equirectangular shader
+	 * @remarks
+	 * You can get faster start-up by invoking this method during your texture's network fetch for increased concurrency.
+	 */
+	compileEquirectangularShader(): void;
 
-    /**
-     * Frees the GPU-related resources allocated by this instance
-     * @remarks
-     * Call this method whenever this instance is no longer used in your app.
-     */
-    dispose(): void;
+	/**
+	 * Frees the GPU-related resources allocated by this instance
+	 * @remarks
+	 * Call this method whenever this instance is no longer used in your app.
+	 */
+	dispose(): void;
 }

package/three/src/extras/ShapeUtils.d.ts

@@ -1,4 +1,4 @@
-import { Vector2Like } from "../math/Vector2.js";
+import { Vector2Like } from '../math/Vector2.js';
 
 /**
  * A class containing utility functions for shapes.
@@ -7,19 +7,19 @@ import { Vector2Like } from "../math/Vector2.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ShapeUtils.js | Source}
  */
 export class ShapeUtils {
-    /**
-     * Calculate area of a ( 2D ) contour polygon.
-     */
-    static area(contour: readonly Vector2Like[]): number;
+	/**
+	 * Calculate area of a ( 2D ) contour polygon.
+	 */
+	static area(contour: readonly Vector2Like[]): number;
 
-    /**
-     * Note that this is a linear function so it is necessary to calculate separately for x, y components of a polygon.
-     * @remarks Used internally by {@link THREE.Path | Path}, {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry}.
-     */
-    static isClockWise(pts: readonly Vector2Like[]): boolean;
+	/**
+	 * Note that this is a linear function so it is necessary to calculate separately for x, y components of a polygon.
+	 * @remarks Used internally by {@link THREE.Path | Path}, {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry}.
+	 */
+	static isClockWise(pts: readonly Vector2Like[]): boolean;
 
-    /**
-     * Used internally by {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry} to calculate faces in shapes with holes.
-     */
-    static triangulateShape(contour: Vector2Like[], holes: Vector2Like[][]): number[][];
+	/**
+	 * Used internally by {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry} to calculate faces in shapes with holes.
+	 */
+	static triangulateShape(contour: Vector2Like[], holes: Vector2Like[][]): number[][];
 }

package/three/src/extras/TextureUtils.d.ts

@@ -1,5 +1,5 @@
-import { CompressedPixelFormat, PixelFormat, TextureDataType } from "../constants.js";
-import { Texture } from "../textures/Texture.js";
+import { CompressedPixelFormat, PixelFormat, TextureDataType } from '../constants.js';
+import { Texture } from '../textures/Texture.js';
 
 /**
  * Scales the texture as large as possible within its surface without cropping or stretching the texture. The method
@@ -22,21 +22,16 @@ declare function fill(texture: Texture): Texture;
  * Given the width, height, format, and type of a texture. Determines how many bytes must be used to represent the
  * texture.
  */
-declare function getByteLength(
-    width: number,
-    height: number,
-    format: PixelFormat | CompressedPixelFormat,
-    type: TextureDataType,
-): number;
+declare function getByteLength(width: number, height: number, format: PixelFormat | CompressedPixelFormat, type: TextureDataType): number;
 
 /**
  * A class containing utility functions for textures.
  */
 declare const TextureUtils: {
-    contain: typeof contain;
-    cover: typeof cover;
-    fill: typeof fill;
-    getByteLength: typeof getByteLength;
+	contain: typeof contain;
+	cover: typeof cover;
+	fill: typeof fill;
+	getByteLength: typeof getByteLength;
 };
 
 export { contain, cover, fill, getByteLength, TextureUtils };

package/three/src/extras/core/Curve.d.ts

@@ -1,10 +1,10 @@
-import { Vector2 } from "../../math/Vector2.js";
-import { Vector3 } from "../../math/Vector3.js";
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
 
 export interface CurveJSON {
-    metadata: { version: number; type: string; generator: string };
-    arcLengthDivisions: number;
-    type: string;
+	metadata: { version: number; type: string; generator: string };
+	arcLengthDivisions: number;
+	type: string;
 }
 
 /**
@@ -32,131 +32,131 @@ export interface CurveJSON {
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Curve.js | Source}
  */
 export abstract class Curve<TVector extends Vector2 | Vector3> {
-    protected constructor();
-
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `Curve`
-     */
-    readonly type: string | "Curve";
-
-    /**
-     * This value determines the amount of divisions when calculating the cumulative segment lengths of a {@link Curve}
-     * via {@link .getLengths}.
-     * To ensure precision when using methods like {@link .getSpacedPoints}, it is recommended to increase {@link .arcLengthDivisions} if the {@link Curve} is very large.
-     * @defaultValue `200`
-     * @remarks Expects a `Integer`
-     */
-    arcLengthDivisions: number;
-
-    /**
-     * Returns a vector for a given position on the curve.
-     * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
-     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
-     */
-    getPoint(t: number, optionalTarget?: TVector): TVector;
-
-    /**
-     * Returns a vector for a given position on the {@link Curve} according to the arc length.
-     * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
-     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
-     */
-    getPointAt(u: number, optionalTarget?: TVector): TVector;
-
-    /**
-     * Returns a set of divisions `+1` points using {@link .getPoint | getPoint(t)}.
-     * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
-     */
-    getPoints(divisions?: number): TVector[];
-
-    /**
-     * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
-     * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
-     */
-    getSpacedPoints(divisions?: number): TVector[];
-
-    /**
-     * Get total {@link Curve} arc length.
-     */
-    getLength(): number;
-
-    /**
-     * Get list of cumulative segment lengths.
-     * @param divisions Expects a `Integer`
-     */
-    getLengths(divisions?: number): number[];
-
-    /**
-     * Update the cumulative segment distance cache
-     * @remarks
-     * The method must be called every time {@link Curve} parameters are changed
-     * If an updated {@link Curve} is part of a composed {@link Curve} like {@link THREE.CurvePath | CurvePath},
-     * {@link .updateArcLengths}() must be called on the composed curve, too.
-     */
-    updateArcLengths(): void;
-
-    /**
-     * Given u in the range `[ 0, 1 ]`,
-     * @remarks
-     * `u` and `t` can then be used to give you points which are equidistant from the ends of the curve, using {@link .getPoint}.
-     * @param u Expects a `Float`
-     * @param distance Expects a `Float`
-     * @returns `t` also in the range `[ 0, 1 ]`. Expects a `Float`.
-     */
-    getUtoTmapping(u: number, distance: number): number;
-
-    /**
-     * Returns a unit vector tangent at t
-     * @remarks
-     * If the derived {@link Curve} does not implement its tangent derivation, two points a small delta apart will be used to find its gradient which seems to give a reasonable approximation.
-     * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
-     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
-     */
-    getTangent(t: number, optionalTarget?: TVector): TVector;
-
-    /**
-     * Returns tangent at a point which is equidistant to the ends of the {@link Curve} from the point given in {@link .getTangent}.
-     * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
-     * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
-     */
-    getTangentAt(u: number, optionalTarget?: TVector): TVector;
-
-    /**
-     * Generates the Frenet Frames
-     * @remarks
-     * Requires a {@link Curve} definition in 3D space
-     * Used in geometries like {@link THREE.TubeGeometry | TubeGeometry} or {@link THREE.ExtrudeGeometry | ExtrudeGeometry}.
-     * @param segments Expects a `Integer`
-     * @param closed
-     */
-    computeFrenetFrames(
-        segments: number,
-        closed?: boolean,
-    ): {
-        tangents: Vector3[];
-        normals: Vector3[];
-        binormals: Vector3[];
-    };
-
-    /**
-     * Creates a clone of this instance.
-     */
-    clone(): this;
-    /**
-     * Copies another {@link Curve} object to this instance.
-     * @param source
-     */
-    copy(source: Curve<TVector>): this;
-
-    /**
-     * Returns a JSON object representation of this instance.
-     */
-    toJSON(): CurveJSON;
-
-    /**
-     * Copies the data from the given JSON object to this instance.
-     * @param json
-     */
-    fromJSON(json: CurveJSON): this;
+	protected constructor();
+
+	/**
+	 * A Read-only _string_ to check if `this` object type.
+	 * @remarks Sub-classes will update this value.
+	 * @defaultValue `Curve`
+	 */
+	readonly type: string | 'Curve';
+
+	/**
+	 * This value determines the amount of divisions when calculating the cumulative segment lengths of a {@link Curve}
+	 * via {@link .getLengths}.
+	 * To ensure precision when using methods like {@link .getSpacedPoints}, it is recommended to increase {@link .arcLengthDivisions} if the {@link Curve} is very large.
+	 * @defaultValue `200`
+	 * @remarks Expects a `Integer`
+	 */
+	arcLengthDivisions: number;
+
+	/**
+	 * Returns a vector for a given position on the curve.
+	 * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+	 * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
+	 */
+	getPoint(t: number, optionalTarget?: TVector): TVector;
+
+	/**
+	 * Returns a vector for a given position on the {@link Curve} according to the arc length.
+	 * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+	 * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
+	 */
+	getPointAt(u: number, optionalTarget?: TVector): TVector;
+
+	/**
+	 * Returns a set of divisions `+1` points using {@link .getPoint | getPoint(t)}.
+	 * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
+	 */
+	getPoints(divisions?: number): TVector[];
+
+	/**
+	 * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
+	 * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
+	 */
+	getSpacedPoints(divisions?: number): TVector[];
+
+	/**
+	 * Get total {@link Curve} arc length.
+	 */
+	getLength(): number;
+
+	/**
+	 * Get list of cumulative segment lengths.
+	 * @param divisions Expects a `Integer`
+	 */
+	getLengths(divisions?: number): number[];
+
+	/**
+	 * Update the cumulative segment distance cache
+	 * @remarks
+	 * The method must be called every time {@link Curve} parameters are changed
+	 * If an updated {@link Curve} is part of a composed {@link Curve} like {@link THREE.CurvePath | CurvePath},
+	 * {@link .updateArcLengths}() must be called on the composed curve, too.
+	 */
+	updateArcLengths(): void;
+
+	/**
+	 * Given u in the range `[ 0, 1 ]`,
+	 * @remarks
+	 * `u` and `t` can then be used to give you points which are equidistant from the ends of the curve, using {@link .getPoint}.
+	 * @param u Expects a `Float`
+	 * @param distance Expects a `Float`
+	 * @returns `t` also in the range `[ 0, 1 ]`. Expects a `Float`.
+	 */
+	getUtoTmapping(u: number, distance: number): number;
+
+	/**
+	 * Returns a unit vector tangent at t
+	 * @remarks
+	 * If the derived {@link Curve} does not implement its tangent derivation, two points a small delta apart will be used to find its gradient which seems to give a reasonable approximation.
+	 * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+	 * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
+	 */
+	getTangent(t: number, optionalTarget?: TVector): TVector;
+
+	/**
+	 * Returns tangent at a point which is equidistant to the ends of the {@link Curve} from the point given in {@link .getTangent}.
+	 * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
+	 * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
+	 */
+	getTangentAt(u: number, optionalTarget?: TVector): TVector;
+
+	/**
+	 * Generates the Frenet Frames
+	 * @remarks
+	 * Requires a {@link Curve} definition in 3D space
+	 * Used in geometries like {@link THREE.TubeGeometry | TubeGeometry} or {@link THREE.ExtrudeGeometry | ExtrudeGeometry}.
+	 * @param segments Expects a `Integer`
+	 * @param closed
+	 */
+	computeFrenetFrames(
+		segments: number,
+		closed?: boolean
+	): {
+		tangents: Vector3[];
+		normals: Vector3[];
+		binormals: Vector3[];
+	};
+
+	/**
+	 * Creates a clone of this instance.
+	 */
+	clone(): this;
+	/**
+	 * Copies another {@link Curve} object to this instance.
+	 * @param source
+	 */
+	copy(source: Curve<TVector>): this;
+
+	/**
+	 * Returns a JSON object representation of this instance.
+	 */
+	toJSON(): CurveJSON;
+
+	/**
+	 * Copies the data from the given JSON object to this instance.
+	 * @param json
+	 */
+	fromJSON(json: CurveJSON): this;
 }

package/three/src/extras/core/CurvePath.d.ts

@@ -1,10 +1,10 @@
-import { Vector2 } from "../../math/Vector2.js";
-import { Vector3 } from "../../math/Vector3.js";
-import { Curve, CurveJSON } from "./Curve.js";
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { Curve, CurveJSON } from './Curve.js';
 
 export interface CurvePathJSON extends CurveJSON {
-    autoClose: boolean;
-    curves: CurveJSON[];
+	autoClose: boolean;
+	curves: CurveJSON[];
 }
 
 /**
@@ -15,63 +15,63 @@ export interface CurvePathJSON extends CurveJSON {
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/CurvePath.js | Source}
  */
 export class CurvePath<TVector extends Vector2 | Vector3> extends Curve<TVector> {
-    /**
-     * The constructor take no parameters.
-     */
-    constructor();
+	/**
+	 * The constructor take no parameters.
+	 */
+	constructor();
 
-    /**
-     * A Read-only _string_ to check if `this` object type.
-     * @remarks Sub-classes will update this value.
-     * @defaultValue `CurvePath`
-     */
-    override readonly type: string | "CurvePath";
+	/**
+	 * A Read-only _string_ to check if `this` object type.
+	 * @remarks Sub-classes will update this value.
+	 * @defaultValue `CurvePath`
+	 */
+	override readonly type: string | 'CurvePath';
 
-    /**
-     * The array of {@link Curve | Curves}.
-     * @defaultValue `[]`
-     */
-    curves: Array<Curve<TVector>>;
+	/**
+	 * The array of {@link Curve | Curves}.
+	 * @defaultValue `[]`
+	 */
+	curves: Array<Curve<TVector>>;
 
-    /**
-     * Whether or not to automatically close the path.
-     * @defaultValue false
-     */
-    autoClose: boolean;
+	/**
+	 * Whether or not to automatically close the path.
+	 * @defaultValue false
+	 */
+	autoClose: boolean;
 
-    /**
-     * Add a curve to the {@link .curves} array.
-     * @param curve
-     */
-    add(curve: Curve<TVector>): void;
-    /**
-     * Adds a {@link LineCurve | lineCurve} to close the path.
-     */
-    closePath(): this;
+	/**
+	 * Add a curve to the {@link .curves} array.
+	 * @param curve
+	 */
+	add(curve: Curve<TVector>): void;
+	/**
+	 * Adds a {@link LineCurve | lineCurve} to close the path.
+	 */
+	closePath(): this;
 
-    getPoint(t: number, optionalTarget?: TVector): TVector;
+	getPoint(t: number, optionalTarget?: TVector): TVector;
 
-    /**
-     * Get list of cumulative curve lengths of the curves in the {@link .curves} array.
-     */
-    getCurveLengths(): number[];
+	/**
+	 * Get list of cumulative curve lengths of the curves in the {@link .curves} array.
+	 */
+	getCurveLengths(): number[];
 
-    /**
-     * Returns an array of points representing a sequence of curves
-     * @remarks
-     * The `division` parameter defines the number of pieces each curve is divided into
-     * However, for optimization and quality purposes, the actual sampling resolution for each curve depends on its type
-     * For example, for a {@link THREE.LineCurve | LineCurve}, the returned number of points is always just 2.
-     * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `12`
-     */
-    override getPoints(divisions?: number): TVector[];
+	/**
+	 * Returns an array of points representing a sequence of curves
+	 * @remarks
+	 * The `division` parameter defines the number of pieces each curve is divided into
+	 * However, for optimization and quality purposes, the actual sampling resolution for each curve depends on its type
+	 * For example, for a {@link THREE.LineCurve | LineCurve}, the returned number of points is always just 2.
+	 * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `12`
+	 */
+	override getPoints(divisions?: number): TVector[];
 
-    /**
-     * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
-     * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `40`
-     */
-    override getSpacedPoints(divisions?: number): TVector[];
+	/**
+	 * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
+	 * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `40`
+	 */
+	override getSpacedPoints(divisions?: number): TVector[];
 
-    toJSON(): CurvePathJSON;
-    fromJSON(json: CurvePathJSON): this;
+	toJSON(): CurvePathJSON;
+	fromJSON(json: CurvePathJSON): this;
 }