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

package/three/src/nodes/display/DenoiseNode.d.ts

@@ -1,38 +1,32 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Matrix4 } from "../../math/Matrix4.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Camera } from '../../cameras/Camera.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class DenoiseNode extends TempNode {
-    textureNode: Node;
-    depthNode: Node;
-    normalNode: Node;
-    noiseNode: Node;
+	textureNode: Node;
+	depthNode: Node;
+	normalNode: Node;
+	noiseNode: Node;
 
-    cameraProjectionMatrixInversion: UniformNode<Matrix4>;
-    lumaPhi: UniformNode<number>;
-    depthPhi: UniformNode<number>;
-    normalPhi: UniformNode<number>;
-    radius: UniformNode<number>;
-    index: UniformNode<number>;
+	cameraProjectionMatrixInversion: UniformNode<Matrix4>;
+	lumaPhi: UniformNode<number>;
+	depthPhi: UniformNode<number>;
+	normalPhi: UniformNode<number>;
+	radius: UniformNode<number>;
+	index: UniformNode<number>;
 
-    constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
+	constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
 }
 
-export const denoise: (
-    node: NodeRepresentation,
-    depthNode: NodeRepresentation,
-    normalNode: NodeRepresentation,
-    noiseNode: NodeRepresentation,
-    camera: Camera,
-) => ShaderNodeObject<DenoiseNode>;
+export const denoise: (node: NodeRepresentation, depthNode: NodeRepresentation, normalNode: NodeRepresentation, noiseNode: NodeRepresentation, camera: Camera) => ShaderNodeObject<DenoiseNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        denoise: typeof denoise;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		denoise: typeof denoise;
+	}
 }
 
 export default DenoiseNode;

package/three/src/nodes/display/DepthOfFieldNode.d.ts

@@ -1,30 +1,24 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class DepthOfFieldNode extends TempNode {
-    textureNode: TextureNode;
-    viewZNode: Node;
+	textureNode: TextureNode;
+	viewZNode: Node;
 
-    focus: UniformNode<number>;
-    aperture: UniformNode<number>;
-    maxblur: UniformNode<number>;
+	focus: UniformNode<number>;
+	aperture: UniformNode<number>;
+	maxblur: UniformNode<number>;
 
-    constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
+	constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
 }
 
-export const dof: (
-    node: NodeRepresentation,
-    viewZNode: NodeRepresentation,
-    focus?: NodeRepresentation,
-    aperture?: NodeRepresentation,
-    maxblur?: NodeRepresentation,
-) => ShaderNodeObject<DepthOfFieldNode>;
+export const dof: (node: NodeRepresentation, viewZNode: NodeRepresentation, focus?: NodeRepresentation, aperture?: NodeRepresentation, maxblur?: NodeRepresentation) => ShaderNodeObject<DepthOfFieldNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        dof: typeof dof;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		dof: typeof dof;
+	}
 }

package/three/src/nodes/display/DotScreenNode.d.ts

@@ -1,27 +1,22 @@
-import { Vector2 } from "../../math/Vector2.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Vector2 } from '../../math/Vector2.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class DotScreenNode extends TempNode {
-    inputNode: Node;
-    center: UniformNode<Vector2>;
-    angle: UniformNode<number>;
-    scale: UniformNode<number>;
+	inputNode: Node;
+	center: UniformNode<Vector2>;
+	angle: UniformNode<number>;
+	scale: UniformNode<number>;
 
-    constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
+	constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
 }
 
-export const dotScreen: (
-    node: NodeRepresentation,
-    center?: Vector2,
-    angle?: number,
-    scale?: number,
-) => ShaderNodeObject<DotScreenNode>;
+export const dotScreen: (node: NodeRepresentation, center?: Vector2, angle?: number, scale?: number) => ShaderNodeObject<DotScreenNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        dotScreen: typeof dotScreen;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		dotScreen: typeof dotScreen;
+	}
 }

package/three/src/nodes/display/FXAANode.d.ts

@@ -1,19 +1,19 @@
-import TextureNode from "../accessors/TextureNode.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from '../accessors/TextureNode.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class FXAANode extends TempNode {
-    textureNode: TextureNode;
+	textureNode: TextureNode;
 
-    constructor(textureNode: TextureNode);
+	constructor(textureNode: TextureNode);
 }
 
 export const fxaa: (node: NodeRepresentation) => ShaderNodeObject<FXAANode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        fxaa: typeof fxaa;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		fxaa: typeof fxaa;
+	}
 }
 
 export default FXAANode;

package/three/src/nodes/display/FilmNode.d.ts

@@ -1,25 +1,21 @@
-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';
 
 declare class FilmNode extends TempNode {
-    inputNode: Node;
-    intensityNode: Node | null;
-    uvNode: Node | null;
+	inputNode: Node;
+	intensityNode: Node | null;
+	uvNode: Node | null;
 
-    constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
+	constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
 }
 
-export const film: (
-    inputNode: NodeRepresentation,
-    intensityNode?: NodeRepresentation | null,
-    uvNode?: NodeRepresentation | null,
-) => ShaderNodeObject<FilmNode>;
+export const film: (inputNode: NodeRepresentation, intensityNode?: NodeRepresentation | null, uvNode?: NodeRepresentation | null) => ShaderNodeObject<FilmNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        film: typeof film;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		film: typeof film;
+	}
 }
 
 export default FilmNode;

package/three/src/nodes/display/FrontFacingNode.d.ts

@@ -1,9 +1,9 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FrontFacingNode extends Node {
-    isFrontFacingNode: true;
-    constructor();
+	isFrontFacingNode: true;
+	constructor();
 }
 
 export const frontFacing: ShaderNodeObject<FrontFacingNode>;

package/three/src/nodes/display/GTAONode.d.ts

@@ -1,46 +1,42 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Matrix4 } from "../../math/Matrix4.js";
-import { Vector2 } from "../../math/Vector2.js";
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Camera } from '../../cameras/Camera.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { Vector2 } from '../../math/Vector2.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class GTAONode extends TempNode {
-    depthNode: Node;
-    normalNode: Node;
+	depthNode: Node;
+	normalNode: Node;
 
-    radius: ShaderNodeObject<UniformNode<number>>;
-    resolution: ShaderNodeObject<UniformNode<Vector2>>;
-    thickness: ShaderNodeObject<UniformNode<number>>;
-    distanceExponent: ShaderNodeObject<UniformNode<number>>;
-    distanceFallOff: ShaderNodeObject<UniformNode<number>>;
-    scale: ShaderNodeObject<UniformNode<number>>;
-    noiseNode: ShaderNodeObject<TextureNode>;
+	radius: ShaderNodeObject<UniformNode<number>>;
+	resolution: ShaderNodeObject<UniformNode<Vector2>>;
+	thickness: ShaderNodeObject<UniformNode<number>>;
+	distanceExponent: ShaderNodeObject<UniformNode<number>>;
+	distanceFallOff: ShaderNodeObject<UniformNode<number>>;
+	scale: ShaderNodeObject<UniformNode<number>>;
+	noiseNode: ShaderNodeObject<TextureNode>;
 
-    cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-    cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+	cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+	cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
 
-    SAMPLES: ShaderNodeObject<UniformNode<number>>;
+	SAMPLES: ShaderNodeObject<UniformNode<number>>;
 
-    constructor(depthNode: Node, normalNode: Node, camera: Camera);
+	constructor(depthNode: Node, normalNode: Node, camera: Camera);
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+	getTextureNode(): ShaderNodeObject<TextureNode>;
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 }
 
-export const ao: (
-    depthNode: NodeRepresentation,
-    normalNode: NodeRepresentation,
-    camera: Camera,
-) => ShaderNodeObject<GTAONode>;
+export const ao: (depthNode: NodeRepresentation, normalNode: NodeRepresentation, camera: Camera) => ShaderNodeObject<GTAONode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        ao: typeof ao;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		ao: typeof ao;
+	}
 }
 
 export default GTAONode;

package/three/src/nodes/display/GaussianBlurNode.d.ts

@@ -1,31 +1,27 @@
-import { Vector2 } from "../../math/Vector2.js";
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Vector2 } from '../../math/Vector2.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class GaussianBlurNode extends TempNode {
-    textureNode: TextureNode;
-    directionNode: Node | null;
-    sigma: number;
+	textureNode: TextureNode;
+	directionNode: Node | null;
+	sigma: number;
 
-    resolution: Vector2;
+	resolution: Vector2;
 
-    constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
+	constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 
-    getTextureNode(): TextureNode;
+	getTextureNode(): TextureNode;
 }
 
-export const gaussianBlur: (
-    node: NodeRepresentation,
-    directionNode?: NodeRepresentation | null,
-    sigma?: number,
-) => ShaderNodeObject<GaussianBlurNode>;
+export const gaussianBlur: (node: NodeRepresentation, directionNode?: NodeRepresentation | null, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        gaussianBlur: typeof gaussianBlur;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		gaussianBlur: typeof gaussianBlur;
+	}
 }

package/three/src/nodes/display/Lut3DNode.d.ts

@@ -1,30 +1,25 @@
-import { Data3DTexture } from "../../textures/Data3DTexture.js";
-import Texture3DNode from "../accessors/Texture3DNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Data3DTexture } from '../../textures/Data3DTexture.js';
+import Texture3DNode from '../accessors/Texture3DNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class Lut3DNode extends TempNode {
-    inputNode: Node;
-    lutNode: Texture3DNode;
-    size: ShaderNodeObject<UniformNode<number>>;
-    intensityNode: UniformNode<number>;
+	inputNode: Node;
+	lutNode: Texture3DNode;
+	size: ShaderNodeObject<UniformNode<number>>;
+	intensityNode: UniformNode<number>;
 
-    constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
+	constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
 }
 
-export const lut3D: (
-    node: NodeRepresentation,
-    lut: NodeRepresentation,
-    size: number,
-    intensity: NodeRepresentation,
-) => ShaderNodeObject<Lut3DNode>;
+export const lut3D: (node: NodeRepresentation, lut: NodeRepresentation, size: number, intensity: NodeRepresentation) => ShaderNodeObject<Lut3DNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        lut3D: typeof lut3D;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		lut3D: typeof lut3D;
+	}
 }
 
 export default Lut3DNode;

package/three/src/nodes/display/NormalMapNode.d.ts

@@ -1,21 +1,21 @@
-import { NormalMapTypes } from "../../constants.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NormalMapTypes } from '../../constants.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class NormalMapNode extends TempNode {
-    node: Node;
-    scaleNode: Node | null;
+	node: Node;
+	scaleNode: Node | null;
 
-    normalMapType: NormalMapTypes;
+	normalMapType: NormalMapTypes;
 
-    constructor(node: Node, scaleNode?: Node | null);
+	constructor(node: Node, scaleNode?: Node | null);
 }
 
 export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        normalMap: typeof normalMap;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		normalMap: typeof normalMap;
+	}
 }

package/three/src/nodes/display/PassNode.d.ts

@@ -1,56 +1,56 @@
-import { Camera } from "../../cameras/Camera.js";
-import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
-import { Scene } from "../../scenes/Scene.js";
-import { Texture } from "../../textures/Texture.js";
-import TextureNode from "../accessors/TextureNode.js";
-import MRTNode from "../core/MRTNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Camera } from '../../cameras/Camera.js';
+import { RenderTarget, RenderTargetOptions } from '../../core/RenderTarget.js';
+import { Scene } from '../../scenes/Scene.js';
+import { Texture } from '../../textures/Texture.js';
+import TextureNode from '../accessors/TextureNode.js';
+import MRTNode from '../core/MRTNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class PassTextureNode extends TextureNode {
-    passNode: PassNode;
+	passNode: PassNode;
 
-    constructor(passNode: PassNode, texture: Texture);
+	constructor(passNode: PassNode, texture: Texture);
 }
 
 declare class PassMultipleTextureNode extends PassTextureNode {
-    textureName: string;
+	textureName: string;
 
-    constructor(passNode: PassNode, textureName: string);
+	constructor(passNode: PassNode, textureName: string);
 }
 
 declare class PassNode extends TempNode {
-    scope: PassNodeScope;
-    scene: Scene;
-    camera: Camera;
+	scope: PassNodeScope;
+	scene: Scene;
+	camera: Camera;
 
-    renderTarget: RenderTarget;
+	renderTarget: RenderTarget;
 
-    readonly isPassNode: true;
+	readonly isPassNode: true;
 
-    constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
+	constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
 
-    setMRT(mrt: MRTNode | null): this;
+	setMRT(mrt: MRTNode | null): this;
 
-    getMRT(): MRTNode | null;
+	getMRT(): MRTNode | null;
 
-    getTexture(name: string): Texture;
+	getTexture(name: string): Texture;
 
-    getTextureNode(name?: string): ShaderNodeObject<Node>;
+	getTextureNode(name?: string): ShaderNodeObject<Node>;
 
-    getViewZNode(name?: string): ShaderNodeObject<Node>;
+	getViewZNode(name?: string): ShaderNodeObject<Node>;
 
-    getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
+	getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 
-    setPixelRatio(pixelRatio: number): void;
+	setPixelRatio(pixelRatio: number): void;
 
-    dispose(): void;
+	dispose(): void;
 
-    static COLOR: "color";
-    static DEPTH: "depth";
+	static COLOR: 'color';
+	static DEPTH: 'depth';
 }
 
 export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;

package/three/src/nodes/display/PixelationPassNode.d.ts

@@ -1,67 +1,41 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Scene } from "../../scenes/Scene.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import PassNode from "./PassNode.js";
+import { Camera } from '../../cameras/Camera.js';
+import { Scene } from '../../scenes/Scene.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import PassNode from './PassNode.js';
 
 declare class PixelationNode extends TempNode {
-    textureNode: Node;
-    depthNode: Node;
-    normalNode: Node;
+	textureNode: Node;
+	depthNode: Node;
+	normalNode: Node;
 
-    pixelSize: Node;
-    normalEdgeStrength: Node;
-    depthEdgeStrength: Node;
+	pixelSize: Node;
+	normalEdgeStrength: Node;
+	depthEdgeStrength: Node;
 
-    constructor(
-        textureNode: Node,
-        depthNode: Node,
-        normalNode: Node,
-        pixelSize: Node,
-        normalEdgeStrength: Node,
-        depthEdgeStrength: Node,
-    );
+	constructor(textureNode: Node, depthNode: Node, normalNode: Node, pixelSize: Node, normalEdgeStrength: Node, depthEdgeStrength: Node);
 }
 
-declare const pixelation: (
-    node: NodeRepresentation,
-    depthNode: NodeRepresentation,
-    normalNode: NodeRepresentation,
-    pixelSize?: number,
-    normalEdgeStrength?: number,
-    depthEdgeStrength?: number,
-) => ShaderNodeObject<PixelationNode>;
+declare const pixelation: (node: NodeRepresentation, depthNode: NodeRepresentation, normalNode: NodeRepresentation, pixelSize?: number, normalEdgeStrength?: number, depthEdgeStrength?: number) => ShaderNodeObject<PixelationNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        pixelation: typeof pixelation;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		pixelation: typeof pixelation;
+	}
 }
 
 declare class PixelationPassNode extends PassNode {
-    pixelSize: UniformNode<number>;
-    normalEdgeStrength: UniformNode<number>;
-    depthEdgeStrength: UniformNode<number>;
+	pixelSize: UniformNode<number>;
+	normalEdgeStrength: UniformNode<number>;
+	depthEdgeStrength: UniformNode<number>;
 
-    readonly isPixelationPassNode: true;
+	readonly isPixelationPassNode: true;
 
-    constructor(
-        scene: Scene,
-        camera: Camera,
-        pixelSize: number,
-        normalEdgeStrength: number,
-        depthEdgeStrength: number,
-    );
+	constructor(scene: Scene, camera: Camera, pixelSize: number, normalEdgeStrength: number, depthEdgeStrength: number);
 }
 
-export const pixelationPass: (
-    scene: Scene,
-    camera: Camera,
-    pixelSize: UniformNode<number>,
-    normalEdgeStrength: UniformNode<number>,
-    depthEdgeStrength: UniformNode<number>,
-) => ShaderNodeObject<PixelationPassNode>;
+export const pixelationPass: (scene: Scene, camera: Camera, pixelSize: UniformNode<number>, normalEdgeStrength: UniformNode<number>, depthEdgeStrength: UniformNode<number>) => ShaderNodeObject<PixelationPassNode>;
 
 export default PixelationPassNode;