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

package/three/src/nodes/shadernode/ShaderNode.d.ts

@@ -1,79 +1,62 @@
-import ConstNode from "../core/ConstNode.js";
-import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import StackNode from "../core/StackNode.js";
+import ConstNode from '../core/ConstNode.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import StackNode from '../core/StackNode.js';
 
 export interface NodeElements {
-    toGlobal: (node: Node) => Node;
-
-    append: typeof append;
-
-    toColor: typeof color;
-    toFloat: typeof float;
-    toInt: typeof int;
-    toUint: typeof uint;
-    toBool: typeof bool;
-    toVec2: typeof vec2;
-    toIvec2: typeof ivec2;
-    toUvec2: typeof uvec2;
-    toBvec2: typeof bvec2;
-    toVec3: typeof vec3;
-    toIvec3: typeof ivec3;
-    toUvec3: typeof uvec3;
-    toBvec3: typeof bvec3;
-    toVec4: typeof vec4;
-    toIvec4: typeof ivec4;
-    toUvec4: typeof uvec4;
-    toBvec4: typeof bvec4;
-    toMat2: typeof mat2;
-    toImat2: typeof imat2;
-    toUmat2: typeof umat2;
-    toBmat2: typeof bmat2;
-    toMat3: typeof mat3;
-    toImat3: typeof imat3;
-    toUmat3: typeof umat3;
-    toBmat3: typeof bmat3;
-    toMat4: typeof mat4;
-    toImat4: typeof imat4;
-    toUmat4: typeof umat4;
-    toBmat4: typeof bmat4;
-
-    element: typeof element;
-    convert: typeof convert;
+	toGlobal: (node: Node) => Node;
+
+	append: typeof append;
+
+	toColor: typeof color;
+	toFloat: typeof float;
+	toInt: typeof int;
+	toUint: typeof uint;
+	toBool: typeof bool;
+	toVec2: typeof vec2;
+	toIvec2: typeof ivec2;
+	toUvec2: typeof uvec2;
+	toBvec2: typeof bvec2;
+	toVec3: typeof vec3;
+	toIvec3: typeof ivec3;
+	toUvec3: typeof uvec3;
+	toBvec3: typeof bvec3;
+	toVec4: typeof vec4;
+	toIvec4: typeof ivec4;
+	toUvec4: typeof uvec4;
+	toBvec4: typeof bvec4;
+	toMat2: typeof mat2;
+	toImat2: typeof imat2;
+	toUmat2: typeof umat2;
+	toBmat2: typeof bmat2;
+	toMat3: typeof mat3;
+	toImat3: typeof imat3;
+	toUmat3: typeof umat3;
+	toBmat3: typeof bmat3;
+	toMat4: typeof mat4;
+	toImat4: typeof imat4;
+	toUmat4: typeof umat4;
+	toBmat4: typeof bmat4;
+
+	element: typeof element;
+	convert: typeof convert;
 }
 
 export function addNodeElement(name: string, nodeElement: unknown): void;
 
-export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
-
-export type SwizzleOption = Exclude<
-    | `${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
-    "abs" | "sqrt"
->;
-
-export type Swizzable<T extends Node = Node> =
-    & T
-    & {
-        [key in SwizzleOption | number]: ShaderNodeObject<Node>;
-    };
-
-export type ShaderNodeObject<T extends Node> =
-    & T
-    & {
-        [Key in keyof NodeElements]: T extends { [K in Key]: infer M } ? M
-            : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R
-            : never;
-    }
-    & {
-        [Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M
-            : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown
-                ? (...args: Args) => ShaderNodeObject<T>
-            : never;
-    }
-    & Swizzable<T>;
+export type SwizzleCharacter = 'x' | 'y' | 'z' | 'w' | 'r' | 'g' | 'b' | 'a' | 's' | 't' | 'p' | 'q';
+
+export type SwizzleOption = Exclude<`${SwizzleCharacter}` | `${SwizzleCharacter}${SwizzleCharacter}` | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}` | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`, 'abs' | 'sqrt'>;
+
+export type Swizzable<T extends Node = Node> = T & {
+	[key in SwizzleOption | number]: ShaderNodeObject<Node>;
+};
+
+export type ShaderNodeObject<T extends Node> = T & {
+	[Key in keyof NodeElements]: T extends { [K in Key]: infer M } ? M : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R : never;
+} & {
+	[Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown ? (...args: Args) => ShaderNodeObject<T> : never;
+} & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
 export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
@@ -82,9 +65,7 @@ export type NodeRepresentation<T extends Node = Node> = number | boolean | Node
 export type NodeObjectOption = NodeRepresentation | string;
 
 // same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
-export type NodeObject<T> = T extends Node ? ShaderNodeObject<T>
-    : T extends number | boolean ? ShaderNodeObject<ConstNode<number | boolean>>
-    : T;
+export type NodeObject<T> = T extends Node ? ShaderNodeObject<T> : T extends number | boolean ? ShaderNodeObject<ConstNode<number | boolean>> : T;
 
 // opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
 type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
@@ -99,16 +80,11 @@ type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown,
  *
  * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
  */
-interface Construtors<
-    A extends undefined | [...unknown[]],
-    B extends undefined | [...unknown[]],
-    C extends undefined | [...unknown[]],
-    D extends undefined | [...unknown[]],
-> {
-    a: A;
-    b: B;
-    c: C;
-    d: D;
+interface Construtors<A extends undefined | [...unknown[]], B extends undefined | [...unknown[]], C extends undefined | [...unknown[]], D extends undefined | [...unknown[]]> {
+	a: A;
+	b: B;
+	c: C;
+	d: D;
 }
 
 /**
@@ -118,22 +94,26 @@ interface Construtors<
  * <https://stackoverflow.com/a/52761156/1623826>
  */
 type OverloadedConstructorsOf<T> = T extends {
-    new(...args: infer A1): unknown;
-    new(...args: infer A2): unknown;
-    new(...args: infer A3): unknown;
-    new(...args: infer A4): unknown;
-} ? Construtors<A1, A2, A3, A4>
-    : T extends {
-        new(...args: infer A1): unknown;
-        new(...args: infer A2): unknown;
-        new(...args: infer A3): unknown;
-    } ? Construtors<A1, A2, A3, undefined>
-    : T extends {
-        new(...args: infer A1): unknown;
-        new(...args: infer A2): unknown;
-    } ? Construtors<A1, A2, undefined, undefined>
-    : T extends new(...args: infer A) => unknown ? Construtors<A, undefined, undefined, undefined>
-    : Construtors<undefined, undefined, undefined, undefined>;
+	new (...args: infer A1): unknown;
+	new (...args: infer A2): unknown;
+	new (...args: infer A3): unknown;
+	new (...args: infer A4): unknown;
+}
+	? Construtors<A1, A2, A3, A4>
+	: T extends {
+			new (...args: infer A1): unknown;
+			new (...args: infer A2): unknown;
+			new (...args: infer A3): unknown;
+	  }
+	? Construtors<A1, A2, A3, undefined>
+	: T extends {
+			new (...args: infer A1): unknown;
+			new (...args: infer A2): unknown;
+	  }
+	? Construtors<A1, A2, undefined, undefined>
+	: T extends new (...args: infer A) => unknown
+	? Construtors<A, undefined, undefined, undefined>
+	: Construtors<undefined, undefined, undefined, undefined>;
 
 type AnyConstructors = Construtors<any, any, any, any>;
 
@@ -142,29 +122,21 @@ type AnyConstructors = Construtors<any, any, any, any>;
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 type FilterConstructorsByScope<T extends AnyConstructors, S> = {
-    a: S extends T["a"][0] ? T["a"] : undefined;
-    b: S extends T["b"][0] ? T["b"] : undefined;
-    c: S extends T["c"][0] ? T["c"] : undefined;
-    d: S extends T["d"][0] ? T["d"] : undefined;
+	a: S extends T['a'][0] ? T['a'] : undefined;
+	b: S extends T['b'][0] ? T['b'] : undefined;
+	c: S extends T['c'][0] ? T['c'] : undefined;
+	d: S extends T['d'][0] ? T['d'] : undefined;
 };
 /**
  * "flattens" the tuple into an union type
  */
-type ConstructorUnion<T extends AnyConstructors> =
-    | Exclude<T["a"], undefined>
-    | Exclude<T["b"], undefined>
-    | Exclude<T["c"], undefined>
-    | Exclude<T["d"], undefined>;
+type ConstructorUnion<T extends AnyConstructors> = Exclude<T['a'], undefined> | Exclude<T['b'], undefined> | Exclude<T['c'], undefined> | Exclude<T['d'], undefined>;
 
 /**
  * Extract list of possible scopes - union of the first paramter
  * of all constructors, should it be string
  */
-type ExtractScopes<T extends AnyConstructors> =
-    | (T["a"][0] extends string ? T["a"][0] : never)
-    | (T["b"][0] extends string ? T["b"][0] : never)
-    | (T["c"][0] extends string ? T["c"][0] : never)
-    | (T["d"][0] extends string ? T["d"][0] : never);
+type ExtractScopes<T extends AnyConstructors> = (T['a'][0] extends string ? T['a'][0] : never) | (T['b'][0] extends string ? T['b'][0] : never) | (T['c'][0] extends string ? T['c'][0] : never) | (T['d'][0] extends string ? T['d'][0] : never);
 
 type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
 type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
@@ -174,18 +146,15 @@ export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
 
 type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
 type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
-type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends Node ? R : never) : never;
+type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends Node ? R : never) : never;
 
 export type NodeOrType = Node | string;
 
 export const getConstNodeType: (value: NodeOrType) => string | null;
 
 export class ShaderNode<T = {}, R extends Node = Node> {
-    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
-    call: (
-        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] },
-        builder?: NodeBuilder,
-    ) => ShaderNodeObject<R>;
+	constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+	call: (inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] }, builder?: NodeBuilder) => ShaderNodeObject<R>;
 }
 
 export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
@@ -193,33 +162,17 @@ export function nodeObjects<T>(obj: T): NodeObjects<T>;
 
 export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
 
-export function nodeProxy<T>(
-    nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
+export function nodeProxy<T>(nodeClass: T): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
 
-export function nodeProxy<T, S extends GetPossibleScopes<T>>(
-    nodeClass: T,
-    scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(nodeClass: T, scope: S): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
 
-export function nodeProxy<T, S extends GetPossibleScopes<T>>(
-    nodeClass: T,
-    scope: S,
-    factor: NodeObjectOption,
-): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(nodeClass: T, scope: S, factor: NodeObjectOption): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
 
-export function nodeImmutable<T>(
-    nodeClass: T,
-    ...params: ProxiedTuple<GetConstructors<T>>
-): ShaderNodeObject<ConstructedNode<T>>;
+export function nodeImmutable<T>(nodeClass: T, ...params: ProxiedTuple<GetConstructors<T>>): ShaderNodeObject<ConstructedNode<T>>;
 
 export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
-export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (...args: ProxiedTuple<T>) => R;
-export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (args: ProxiedObject<T>) => R;
+export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(jsFunc: (args: T) => R): (...args: ProxiedTuple<T>) => R;
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(jsFunc: (args: T) => R): (args: ProxiedObject<T>) => R;
 
 export const setCurrentStack: (stack: StackNode | null) => void;
 

package/three/src/nodes/utils/ArrayElementNode.d.ts

@@ -1,9 +1,9 @@
-import Node from "../core/Node.js";
-import { TempNode } from "../Nodes.js";
+import Node from '../core/Node.js';
+import { TempNode } from '../Nodes.js';
 
 export default class ArrayElementNode extends TempNode {
-    node: Node;
-    indexNode: Node;
+	node: Node;
+	indexNode: Node;
 
-    constructor(node: Node, indexNode: Node);
+	constructor(node: Node, indexNode: Node);
 }

package/three/src/nodes/utils/ConvertNode.d.ts

@@ -1,7 +1,7 @@
-import Node from "../core/Node.js";
+import Node from '../core/Node.js';
 
 export default class ConvertNode extends Node {
-    node: Node;
-    convertTo: string;
-    constructor(node: Node, convertTo: string);
+	node: Node;
+	convertTo: string;
+	constructor(node: Node, convertTo: string);
 }

package/three/src/nodes/utils/DiscardNode.d.ts

@@ -1,17 +1,17 @@
-import Node from "../core/Node.js";
-import CondNode from "../math/CondNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import CondNode from '../math/CondNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class DiscardNode extends CondNode {
-    constructor(condNode: Node);
+	constructor(condNode: Node);
 }
 
 export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
 export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
 export const Return: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        discard: typeof discard;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		discard: typeof discard;
+	}
 }

package/three/src/nodes/utils/EquirectUVNode.d.ts

@@ -1,8 +1,8 @@
-import { Node, TempNode } from "../Nodes.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Node, TempNode } from '../Nodes.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class EquirectUVNode extends TempNode {
-    constructor(dirNode?: ShaderNodeObject<Node>);
+	constructor(dirNode?: ShaderNodeObject<Node>);
 }
 
 export const equirectUV: ShaderNodeObject<EquirectUVNode>;

package/three/src/nodes/utils/JoinNode.d.ts

@@ -1,10 +1,10 @@
-import Node from "../core/Node.js";
-import { TempNode } from "../Nodes.js";
+import Node from '../core/Node.js';
+import { TempNode } from '../Nodes.js';
 
 /**
  * This node constructs given type from elements, like vec3(a,b,c)
  */
 export default class JoinNode extends TempNode {
-    nodes: Node[];
-    constructor(nodes: Node[]);
+	nodes: Node[];
+	constructor(nodes: Node[]);
 }

package/three/src/nodes/utils/MatcapUVNode.d.ts

@@ -1,8 +1,8 @@
-import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MatcapUVNode extends TempNode {
-    constructor();
+	constructor();
 }
 
 export const matcapUV: ShaderNodeObject<MatcapUVNode>;

package/three/src/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,14 +1,14 @@
-import { Texture } from "../../textures/Texture.js";
-import TextureNode from "../accessors/TextureNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Texture } from '../../textures/Texture.js';
+import TextureNode from '../accessors/TextureNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MaxMipLevelNode extends UniformNode<0> {
-    constructor(textureNode: TextureNode);
+	constructor(textureNode: TextureNode);
 
-    get textureNode(): TextureNode;
+	get textureNode(): TextureNode;
 
-    get texture(): Texture;
+	get texture(): Texture;
 }
 
 export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;

package/three/src/nodes/utils/OscNode.d.ts

@@ -1,22 +1,18 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export type OscNodeMethod =
-    | typeof OscNode.SINE
-    | typeof OscNode.SQUARE
-    | typeof OscNode.TRIANGLE
-    | typeof OscNode.SAWTOOTH;
+export type OscNodeMethod = typeof OscNode.SINE | typeof OscNode.SQUARE | typeof OscNode.TRIANGLE | typeof OscNode.SAWTOOTH;
 
 export default class OscNode extends Node {
-    static SINE: "sine";
-    static SQUARE: "square";
-    static TRIANGLE: "triangle";
-    static SAWTOOTH: "sawtooth";
+	static SINE: 'sine';
+	static SQUARE: 'square';
+	static TRIANGLE: 'triangle';
+	static SAWTOOTH: 'sawtooth';
 
-    method: OscNodeMethod;
-    timeNode: Node;
+	method: OscNodeMethod;
+	timeNode: Node;
 
-    constructor(method: OscNodeMethod, timeNode?: Node);
+	constructor(method: OscNodeMethod, timeNode?: Node);
 }
 
 export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;

package/three/src/nodes/utils/PackingNode.d.ts

@@ -1,14 +1,14 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type PackingNodeScope = typeof PackingNode.DIRECTION_TO_COLOR | typeof PackingNode.COLOR_TO_DIRECTION;
 
 declare class PackingNode extends TempNode {
-    constructor(scope: PackingNodeScope, node: Node);
+	constructor(scope: PackingNodeScope, node: Node);
 
-    static DIRECTION_TO_COLOR: "directionToColor";
-    static COLOR_TO_DIRECTION: "colorToDirection";
+	static DIRECTION_TO_COLOR: 'directionToColor';
+	static COLOR_TO_DIRECTION: 'colorToDirection';
 }
 
 export default PackingNode;
@@ -16,9 +16,9 @@ export default PackingNode;
 export const directionToColor: (node: NodeRepresentation) => ShaderNodeObject<PackingNode>;
 export const colorToDirection: (node: NodeRepresentation) => ShaderNodeObject<PackingNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        directionToColor: typeof directionToColor;
-        colorToDirection: typeof colorToDirection;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		directionToColor: typeof directionToColor;
+		colorToDirection: typeof colorToDirection;
+	}
 }

package/three/src/nodes/utils/RTTNode.d.ts

@@ -1,45 +1,40 @@
-import { TextureDataType } from "../../constants.js";
-import { RenderTarget } from "../../core/RenderTarget.js";
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { TextureDataType } from '../../constants.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface RTTNodeOptions {
-    type: TextureDataType;
+	type: TextureDataType;
 }
 
 declare class RTTNode extends TextureNode {
-    node: Node;
-    width: number | null;
-    height: number | null;
+	node: Node;
+	width: number | null;
+	height: number | null;
 
-    renderTarget: RenderTarget | null;
+	renderTarget: RenderTarget | null;
 
-    textureNeedsUpdate: boolean;
-    autoUpdate: boolean;
+	textureNeedsUpdate: boolean;
+	autoUpdate: boolean;
 
-    pixelRatio?: number;
+	pixelRatio?: number;
 
-    constructor(node: Node, width?: number | null, height?: number | null, options?: RTTNodeOptions);
+	constructor(node: Node, width?: number | null, height?: number | null, options?: RTTNodeOptions);
 
-    get autoSize(): boolean;
+	get autoSize(): boolean;
 
-    setSize(width: number | null, height: number | null): void;
+	setSize(width: number | null, height: number | null): void;
 
-    setPixelRatio(pixelRatio: number): void;
+	setPixelRatio(pixelRatio: number): void;
 }
 
 export default RTTNode;
 
-export const rtt: (
-    node: NodeRepresentation,
-    width?: number | null,
-    height?: number | null,
-    options?: RTTNodeOptions,
-) => ShaderNodeObject<RTTNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        toTexture: typeof rtt;
-    }
+export const rtt: (node: NodeRepresentation, width?: number | null, height?: number | null, options?: RTTNodeOptions) => ShaderNodeObject<RTTNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		toTexture: typeof rtt;
+	}
 }

package/three/src/nodes/utils/ReflectorNode.d.ts

@@ -1,32 +1,32 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Object3D } from "../../core/Object3D.js";
-import { RenderTarget } from "../../core/RenderTarget.js";
-import TextureNode from "../accessors/TextureNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface ReflectorNodeParameters {
-    target?: Object3D | undefined;
-    resolution?: number | undefined;
-    generateMipmaps?: boolean | undefined;
-    bounces?: boolean | undefined;
+	target?: Object3D | undefined;
+	resolution?: number | undefined;
+	generateMipmaps?: boolean | undefined;
+	bounces?: boolean | undefined;
 }
 
 export default class ReflectorNode extends TextureNode {
-    target: Object3D;
-    resolution: number;
-    generateMipmaps: boolean;
-    bounces: boolean;
+	target: Object3D;
+	resolution: number;
+	generateMipmaps: boolean;
+	bounces: boolean;
 
-    virtualCameras: WeakMap<Camera, Camera>;
-    renderTargets: WeakMap<Camera, RenderTarget>;
+	virtualCameras: WeakMap<Camera, Camera>;
+	renderTargets: WeakMap<Camera, RenderTarget>;
 
-    constructor(parameters?: ReflectorNodeParameters);
+	constructor(parameters?: ReflectorNodeParameters);
 
-    getTextureNode(): TextureNode;
+	getTextureNode(): TextureNode;
 
-    getVirtualCamera(camera: Camera): Camera;
+	getVirtualCamera(camera: Camera): Camera;
 
-    getRenderTarget(camera: Camera): RenderTarget;
+	getRenderTarget(camera: Camera): RenderTarget;
 }
 
 export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;