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

package/three/src/core/Raycaster.d.ts

@@ -1,48 +1,48 @@
-import { Camera } from "../cameras/Camera.js";
-import { Ray } from "../math/Ray.js";
-import { Vector2 } from "../math/Vector2.js";
-import { Vector3 } from "../math/Vector3.js";
-import { XRTargetRaySpace } from "../renderers/webxr/WebXRController.js";
-import { Layers } from "./Layers.js";
-import { Object3D } from "./Object3D.js";
+import { Camera } from '../cameras/Camera.js';
+import { Ray } from '../math/Ray.js';
+import { Vector2 } from '../math/Vector2.js';
+import { Vector3 } from '../math/Vector3.js';
+import { XRTargetRaySpace } from '../renderers/webxr/WebXRController.js';
+import { Layers } from './Layers.js';
+import { Object3D } from './Object3D.js';
 
 export interface Face {
-    a: number;
-    b: number;
-    c: number;
-    normal: Vector3;
-    materialIndex: number;
+	a: number;
+	b: number;
+	c: number;
+	normal: Vector3;
+	materialIndex: number;
 }
 
 export interface Intersection<TIntersected extends Object3D = Object3D> {
-    /** Distance between the origin of the ray and the intersection */
-    distance: number;
-    distanceToRay?: number | undefined;
-    /** Point of intersection, in world coordinates */
-    point: Vector3;
-    index?: number | undefined;
-    /** Intersected face */
-    face?: Face | null | undefined;
-    /** Index of the intersected face */
-    faceIndex?: number | undefined;
-    /** The intersected object */
-    object: TIntersected;
-    uv?: Vector2 | undefined;
-    uv1?: Vector2 | undefined;
-    normal?: Vector3;
-    /** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
-    instanceId?: number | undefined;
-    pointOnLine?: Vector3;
-    batchId?: number;
+	/** Distance between the origin of the ray and the intersection */
+	distance: number;
+	distanceToRay?: number | undefined;
+	/** Point of intersection, in world coordinates */
+	point: Vector3;
+	index?: number | undefined;
+	/** Intersected face */
+	face?: Face | null | undefined;
+	/** Index of the intersected face */
+	faceIndex?: number | undefined;
+	/** The intersected object */
+	object: TIntersected;
+	uv?: Vector2 | undefined;
+	uv1?: Vector2 | undefined;
+	normal?: Vector3;
+	/** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
+	instanceId?: number | undefined;
+	pointOnLine?: Vector3;
+	batchId?: number;
 }
 
 export interface RaycasterParameters {
-    Mesh: any;
-    Line: { threshold: number };
-    Line2?: { threshold: number };
-    LOD: any;
-    Points: { threshold: number };
-    Sprite: any;
+	Mesh: any;
+	Line: { threshold: number };
+	Line2?: { threshold: number };
+	LOD: any;
+	Points: { threshold: number };
+	Sprite: any;
 }
 
 /**
@@ -86,122 +86,114 @@ export interface RaycasterParameters {
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Raycaster.js | Source}
  */
 export class Raycaster {
-    /**
-     * This creates a new {@link Raycaster} object.
-     * @param origin The origin vector where the ray casts from. Default `new Vector3()`
-     * @param direction The direction vector that gives direction to the ray. Should be normalized. Default `new Vector3(0, 0, -1)`
-     * @param near All results returned are further away than near. Near can't be negative. Expects a `Float`. Default `0`
-     * @param far All results returned are closer than far. Far can't be lower than near. Expects a `Float`. Default `Infinity`
-     */
-    constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
+	/**
+	 * This creates a new {@link Raycaster} object.
+	 * @param origin The origin vector where the ray casts from. Default `new Vector3()`
+	 * @param direction The direction vector that gives direction to the ray. Should be normalized. Default `new Vector3(0, 0, -1)`
+	 * @param near All results returned are further away than near. Near can't be negative. Expects a `Float`. Default `0`
+	 * @param far All results returned are closer than far. Far can't be lower than near. Expects a `Float`. Default `Infinity`
+	 */
+	constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
 
-    /**
-     * The {@link THREE.RaycasterRay | Ray} used for the raycasting.
-     */
-    ray: Ray;
+	/**
+	 * The {@link THREE.RaycasterRay | Ray} used for the raycasting.
+	 */
+	ray: Ray;
 
-    /**
-     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance.
-     * This value shouldn't be negative and should be smaller than the far property.
-     * @remarks Expects a `Float`
-     * @defaultValue `0`
-     */
-    near: number;
+	/**
+	 * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+	 * This value shouldn't be negative and should be smaller than the far property.
+	 * @remarks Expects a `Float`
+	 * @defaultValue `0`
+	 */
+	near: number;
 
-    /**
-     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance.
-     * This value shouldn't be negative and should be larger than the near property.
-     * @remarks Expects a `Float`
-     * @defaultValue `Infinity`
-     */
-    far: number;
+	/**
+	 * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+	 * This value shouldn't be negative and should be larger than the near property.
+	 * @remarks Expects a `Float`
+	 * @defaultValue `Infinity`
+	 */
+	far: number;
 
-    /**
-     * The camera to use when raycasting against view-dependent objects such as billboarded objects like {@link THREE.Sprites | Sprites}.
-     * This field can be set manually or is set when calling  {@link setFromCamera}.
-     * @defaultValue `null`
-     */
-    camera: Camera;
+	/**
+	 * The camera to use when raycasting against view-dependent objects such as billboarded objects like {@link THREE.Sprites | Sprites}.
+	 * This field can be set manually or is set when calling  {@link setFromCamera}.
+	 * @defaultValue `null`
+	 */
+	camera: Camera;
 
-    /**
-     * Used by {@link Raycaster} to selectively ignore 3D objects when performing intersection tests.
-     * The following code example ensures that only 3D objects on layer `1` will be honored by the instance of Raycaster.
-     * ```
-     * raycaster.layers.set( 1 );
-     * object.layers.enable( 1 );
-     * ```
-     * @defaultValue `new THREE.Layers()` - See {@link THREE.Layers | Layers}.
-     */
-    layers: Layers;
+	/**
+	 * Used by {@link Raycaster} to selectively ignore 3D objects when performing intersection tests.
+	 * The following code example ensures that only 3D objects on layer `1` will be honored by the instance of Raycaster.
+	 * ```
+	 * raycaster.layers.set( 1 );
+	 * object.layers.enable( 1 );
+	 * ```
+	 * @defaultValue `new THREE.Layers()` - See {@link THREE.Layers | Layers}.
+	 */
+	layers: Layers;
 
-    /**
-     * An data object where threshold is the precision of the {@link Raycaster} when intersecting objects, in world units.
-     * @defaultValue `{ Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }`
-     */
-    params: RaycasterParameters;
+	/**
+	 * An data object where threshold is the precision of the {@link Raycaster} when intersecting objects, in world units.
+	 * @defaultValue `{ Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }`
+	 */
+	params: RaycasterParameters;
 
-    /**
-     * Updates the ray with a new origin and direction
-     * @remarks
-     * Please note that this method only copies the values from the arguments.
-     * @param origin The origin vector where the ray casts from.
-     * @param direction The normalized direction vector that gives direction to the ray.
-     */
-    set(origin: Vector3, direction: Vector3): void;
+	/**
+	 * Updates the ray with a new origin and direction
+	 * @remarks
+	 * Please note that this method only copies the values from the arguments.
+	 * @param origin The origin vector where the ray casts from.
+	 * @param direction The normalized direction vector that gives direction to the ray.
+	 */
+	set(origin: Vector3, direction: Vector3): void;
 
-    /**
-     * Updates the ray with a new origin and direction.
-     * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
-     * @param camera camera from which the ray should originate
-     */
-    setFromCamera(coords: Vector2, camera: Camera): void;
+	/**
+	 * Updates the ray with a new origin and direction.
+	 * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
+	 * @param camera camera from which the ray should originate
+	 */
+	setFromCamera(coords: Vector2, camera: Camera): void;
 
-    /**
-     * Updates the ray with a new origin and direction.
-     * @param controller The controller to copy the position and direction from.
-     */
-    setFromXRController(controller: XRTargetRaySpace): this;
+	/**
+	 * Updates the ray with a new origin and direction.
+	 * @param controller The controller to copy the position and direction from.
+	 */
+	setFromXRController(controller: XRTargetRaySpace): this;
 
-    /**
-     * Checks all intersection between the ray and the object with or without the descendants
-     * @remarks Intersections are returned sorted by distance, closest first
-     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
-     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
-     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
-     * intersections of the ray passing through the back of a face will not be detected
-     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
-     * @see {@link intersectObjects | .intersectObjects()}.
-     * @param object The object to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersection with the object. Default `true`
-     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
-     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
-     * @returns An array of intersections is returned.
-     */
-    intersectObject<TIntersected extends Object3D>(
-        object: Object3D,
-        recursive?: boolean,
-        optionalTarget?: Array<Intersection<TIntersected>>,
-    ): Array<Intersection<TIntersected>>;
+	/**
+	 * Checks all intersection between the ray and the object with or without the descendants
+	 * @remarks Intersections are returned sorted by distance, closest first
+	 * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+	 * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+	 * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+	 * intersections of the ray passing through the back of a face will not be detected
+	 * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+	 * @see {@link intersectObjects | .intersectObjects()}.
+	 * @param object The object to check for intersection with the ray.
+	 * @param recursive If true, it also checks all descendants. Otherwise it only checks intersection with the object. Default `true`
+	 * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+	 * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+	 * @returns An array of intersections is returned.
+	 */
+	intersectObject<TIntersected extends Object3D>(object: Object3D, recursive?: boolean, optionalTarget?: Array<Intersection<TIntersected>>): Array<Intersection<TIntersected>>;
 
-    /**
-     * Checks all intersection between the ray and the objects with or without the descendants
-     * @remarks Intersections are returned sorted by distance, closest first
-     * @remarks Intersections are of the same form as those returned by {@link intersectObject | .intersectObject()}.
-     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
-     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
-     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
-     * intersections of the ray passing through the back of a face will not be detected
-     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
-     * @see {@link intersectObject | .intersectObject()}.
-     * @param objects The objects to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersection with the objects. Default `true`
-     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
-     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
-     * @returns An array of intersections is returned.
-     */
-    intersectObjects<TIntersected extends Object3D>(
-        objects: Object3D[],
-        recursive?: boolean,
-        optionalTarget?: Array<Intersection<TIntersected>>,
-    ): Array<Intersection<TIntersected>>;
+	/**
+	 * Checks all intersection between the ray and the objects with or without the descendants
+	 * @remarks Intersections are returned sorted by distance, closest first
+	 * @remarks Intersections are of the same form as those returned by {@link intersectObject | .intersectObject()}.
+	 * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+	 * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+	 * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+	 * intersections of the ray passing through the back of a face will not be detected
+	 * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+	 * @see {@link intersectObject | .intersectObject()}.
+	 * @param objects The objects to check for intersection with the ray.
+	 * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersection with the objects. Default `true`
+	 * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+	 * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+	 * @returns An array of intersections is returned.
+	 */
+	intersectObjects<TIntersected extends Object3D>(objects: Object3D[], recursive?: boolean, optionalTarget?: Array<Intersection<TIntersected>>): Array<Intersection<TIntersected>>;
 }

package/three/src/core/RenderTarget.d.ts

@@ -1,96 +1,89 @@
-import {
-    ColorSpace,
-    MagnificationTextureFilter,
-    MinificationTextureFilter,
-    PixelFormatGPU,
-    TextureDataType,
-    Wrapping,
-} from "../constants.js";
-import { Vector4 } from "../math/Vector4.js";
-import { DepthTexture } from "../textures/DepthTexture.js";
-import { Texture } from "../textures/Texture.js";
-import { EventDispatcher } from "./EventDispatcher.js";
+import { ColorSpace, MagnificationTextureFilter, MinificationTextureFilter, PixelFormatGPU, TextureDataType, Wrapping } from '../constants.js';
+import { Vector4 } from '../math/Vector4.js';
+import { DepthTexture } from '../textures/DepthTexture.js';
+import { Texture } from '../textures/Texture.js';
+import { EventDispatcher } from './EventDispatcher.js';
 
 export interface RenderTargetOptions {
-    wrapS?: Wrapping | undefined;
-    wrapT?: Wrapping | undefined;
-    magFilter?: MagnificationTextureFilter | undefined;
-    minFilter?: MinificationTextureFilter | undefined;
-    generateMipmaps?: boolean | undefined; // true
-    format?: number | undefined; // RGBAFormat
-    type?: TextureDataType | undefined; // UnsignedByteType
-    anisotropy?: number | undefined; // 1
-    colorSpace?: ColorSpace | undefined;
-    internalFormat?: PixelFormatGPU | null | undefined; // null
-    depthBuffer?: boolean | undefined; // true
-    stencilBuffer?: boolean | undefined; // false
-    resolveDepthBuffer?: boolean | undefined; // true
-    resolveStencilBuffer?: boolean | undefined; // true
-    depthTexture?: DepthTexture | null | undefined; // null
-    /**
-     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
-     * @default 0
-     */
-    samples?: number | undefined;
-    count?: number | undefined;
+	wrapS?: Wrapping | undefined;
+	wrapT?: Wrapping | undefined;
+	magFilter?: MagnificationTextureFilter | undefined;
+	minFilter?: MinificationTextureFilter | undefined;
+	generateMipmaps?: boolean | undefined; // true
+	format?: number | undefined; // RGBAFormat
+	type?: TextureDataType | undefined; // UnsignedByteType
+	anisotropy?: number | undefined; // 1
+	colorSpace?: ColorSpace | undefined;
+	internalFormat?: PixelFormatGPU | null | undefined; // null
+	depthBuffer?: boolean | undefined; // true
+	stencilBuffer?: boolean | undefined; // false
+	resolveDepthBuffer?: boolean | undefined; // true
+	resolveStencilBuffer?: boolean | undefined; // true
+	depthTexture?: DepthTexture | null | undefined; // null
+	/**
+	 * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+	 * @default 0
+	 */
+	samples?: number | undefined;
+	count?: number | undefined;
 }
 
 export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher<{ dispose: {} }> {
-    readonly isRenderTarget: true;
+	readonly isRenderTarget: true;
 
-    width: number;
-    height: number;
-    depth: number;
+	width: number;
+	height: number;
+	depth: number;
 
-    scissor: Vector4;
-    /**
-     * @default false
-     */
-    scissorTest: boolean;
-    viewport: Vector4;
-    textures: TTexture[];
+	scissor: Vector4;
+	/**
+	 * @default false
+	 */
+	scissorTest: boolean;
+	viewport: Vector4;
+	textures: TTexture[];
 
-    /**
-     * @default true
-     */
-    depthBuffer: boolean;
+	/**
+	 * @default true
+	 */
+	depthBuffer: boolean;
 
-    /**
-     * @default false
-     */
-    stencilBuffer: boolean;
+	/**
+	 * @default false
+	 */
+	stencilBuffer: boolean;
 
-    /**
-     * Defines whether the depth buffer should be resolved when rendering into a multisampled render target.
-     * @default true
-     */
-    resolveDepthBuffer: boolean;
+	/**
+	 * Defines whether the depth buffer should be resolved when rendering into a multisampled render target.
+	 * @default true
+	 */
+	resolveDepthBuffer: boolean;
 
-    /**
-     * Defines whether the stencil buffer should be resolved when rendering into a multisampled render target.
-     * This property has no effect when {@link .resolveDepthBuffer} is set to `false`.
-     * @default true
-     */
-    resolveStencilBuffer: boolean;
+	/**
+	 * Defines whether the stencil buffer should be resolved when rendering into a multisampled render target.
+	 * This property has no effect when {@link .resolveDepthBuffer} is set to `false`.
+	 * @default true
+	 */
+	resolveStencilBuffer: boolean;
 
-    /**
-     * @default null
-     */
-    depthTexture: DepthTexture | null;
+	/**
+	 * @default null
+	 */
+	depthTexture: DepthTexture | null;
 
-    /**
-     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
-     * @default 0
-     */
-    samples: number;
+	/**
+	 * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+	 * @default 0
+	 */
+	samples: number;
 
-    constructor(width?: number, height?: number, options?: RenderTargetOptions);
+	constructor(width?: number, height?: number, options?: RenderTargetOptions);
 
-    get texture(): TTexture;
-    set texture(value: TTexture);
+	get texture(): TTexture;
+	set texture(value: TTexture);
 
-    setSize(width: number, height: number, depth?: number): void;
-    clone(): this;
-    copy(source: RenderTarget): this;
-    dispose(): void;
+	setSize(width: number, height: number, depth?: number): void;
+	clone(): this;
+	copy(source: RenderTarget): this;
+	dispose(): void;
 }

package/three/src/core/Uniform.d.ts

@@ -17,22 +17,22 @@
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Uniform.js | Source}
  */
 export class Uniform<T = any> {
-    /**
-     * Create a new instance of {@link THREE.Uniform | Uniform}
-     * @param value An object containing the value to set up the uniform. It's type must be one of the Uniform Types described above.
-     */
-    constructor(value: T);
+	/**
+	 * Create a new instance of {@link THREE.Uniform | Uniform}
+	 * @param value An object containing the value to set up the uniform. It's type must be one of the Uniform Types described above.
+	 */
+	constructor(value: T);
 
-    /**
-     * Current value of the uniform.
-     */
-    value: T;
+	/**
+	 * Current value of the uniform.
+	 */
+	value: T;
 
-    /**
-     * Returns a clone of this uniform.
-     * @remarks
-     * If the uniform's {@link value} property is an {@link Object | Object} with a `clone()` method, this is used,
-     * otherwise the value is copied by assignment Array values are **shared** between cloned {@link THREE.UniformUniform | Uniform}s.
-     */
-    clone(): Uniform<T>;
+	/**
+	 * Returns a clone of this uniform.
+	 * @remarks
+	 * If the uniform's {@link value} property is an {@link Object | Object} with a `clone()` method, this is used,
+	 * otherwise the value is copied by assignment Array values are **shared** between cloned {@link THREE.UniformUniform | Uniform}s.
+	 */
+	clone(): Uniform<T>;
 }

package/three/src/core/UniformsGroup.d.ts

@@ -1,33 +1,33 @@
-import { Usage } from "../constants.js";
-import { EventDispatcher } from "./EventDispatcher.js";
-import { Uniform } from "./Uniform.js";
+import { Usage } from '../constants.js';
+import { EventDispatcher } from './EventDispatcher.js';
+import { Uniform } from './Uniform.js';
 
 /**
  * @see Example: {@link https://threejs.org/examples/#webgl2_ubo | WebGL2 / UBO}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/UniformsGroup.js | Source}
  */
 export class UniformsGroup extends EventDispatcher<{ dispose: {} }> {
-    constructor();
+	constructor();
 
-    readonly isUniformsGroup: true;
+	readonly isUniformsGroup: true;
 
-    id: number;
+	id: number;
 
-    usage: Usage;
+	usage: Usage;
 
-    uniforms: Array<Uniform | Uniform[]>;
+	uniforms: Array<Uniform | Uniform[]>;
 
-    add(uniform: Uniform | Uniform[]): this;
+	add(uniform: Uniform | Uniform[]): this;
 
-    remove(uniform: Uniform | Uniform[]): this;
+	remove(uniform: Uniform | Uniform[]): this;
 
-    setName(name: string): this;
+	setName(name: string): this;
 
-    setUsage(value: Usage): this;
+	setUsage(value: Usage): this;
 
-    dispose(): this;
+	dispose(): this;
 
-    copy(source: UniformsGroup): this;
+	copy(source: UniformsGroup): this;
 
-    clone(): UniformsGroup;
+	clone(): UniformsGroup;
 }

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

@@ -15,8 +15,8 @@ declare function toHalfFloat(val: number): number;
 declare function fromHalfFloat(val: number): number;
 
 declare const DataUtils: {
-    toHalfFloat: typeof toHalfFloat;
-    fromHalfFloat: typeof fromHalfFloat;
+	toHalfFloat: typeof toHalfFloat;
+	fromHalfFloat: typeof fromHalfFloat;
 };
 
 export { DataUtils, fromHalfFloat, toHalfFloat };

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

@@ -6,10 +6,10 @@
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/Earcut.js | Source}
  */
 export const Earcut: {
-    /**
-     * Triangulates the given shape definition by returning an array of triangles
-     * @remarks
-     * A triangle is defined by three consecutive integers representing vertex indices.
-     */
-    triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
+	/**
+	 * Triangulates the given shape definition by returning an array of triangles
+	 * @remarks
+	 * A triangle is defined by three consecutive integers representing vertex indices.
+	 */
+	triangulate(data: number[], holeIndices?: number[], dim?: number): number[];
 };