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

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

@@ -1,20 +1,17 @@
-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 default class PosterizeNode extends Node {
-    sourceNode: Node;
-    stepsNode: Node;
+	sourceNode: Node;
+	stepsNode: Node;
 
-    constructor(sourceNode: Node, stepsNode: Node);
+	constructor(sourceNode: Node, stepsNode: Node);
 }
 
-export const posterize: (
-    sourceNode: NodeRepresentation,
-    stepsNode: NodeRepresentation,
-) => ShaderNodeObject<PosterizeNode>;
+export const posterize: (sourceNode: NodeRepresentation, stepsNode: NodeRepresentation) => ShaderNodeObject<PosterizeNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        posterize: typeof posterize;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		posterize: typeof posterize;
+	}
 }

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

@@ -1,24 +1,24 @@
-import TextureNode from "../accessors/TextureNode.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 TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RGBShiftNode extends TempNode {
-    textureNode: TextureNode;
-    amount: UniformNode<number>;
-    angle: UniformNode<number>;
+	textureNode: TextureNode;
+	amount: UniformNode<number>;
+	angle: UniformNode<number>;
 
-    constructor(textureNode: TextureNode, amount?: number, angle?: number);
+	constructor(textureNode: TextureNode, amount?: number, angle?: number);
 
-    getTextureNode(): TextureNode;
+	getTextureNode(): TextureNode;
 
-    setSize(width: number, height: number): void;
+	setSize(width: number, height: number): void;
 }
 
 export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        rgbShift: typeof rgbShift;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rgbShift: typeof rgbShift;
+	}
 }

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

@@ -1,28 +1,24 @@
-import { ColorSpace, ToneMapping } from "../../constants.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ColorSpace, ToneMapping } from '../../constants.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 declare class RenderOutputNode extends TempNode {
-    colorNode: Node;
-    toneMapping: ToneMapping | null;
-    outputColorSpace: ColorSpace | null;
+	colorNode: Node;
+	toneMapping: ToneMapping | null;
+	outputColorSpace: ColorSpace | null;
 
-    readonly isRenderOutput: true;
+	readonly isRenderOutput: true;
 
-    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
+	constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
 }
 
 export default RenderOutputNode;
 
-export const renderOutput: (
-    color: NodeRepresentation,
-    toneMapping?: ToneMapping | null,
-    outputColorSpace?: ColorSpace | null,
-) => ShaderNodeObject<RenderOutputNode>;
+export const renderOutput: (color: NodeRepresentation, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null) => ShaderNodeObject<RenderOutputNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        renderOutput: typeof renderOutput;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		renderOutput: typeof renderOutput;
+	}
 }

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

@@ -1,17 +1,17 @@
-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';
 
 export default class SobelOperatorNode extends TempNode {
-    textureNode: TextureNode;
+	textureNode: TextureNode;
 
-    constructor(textureNode: TextureNode);
+	constructor(textureNode: TextureNode);
 }
 
 export const sobel: (node: NodeRepresentation) => ShaderNodeObject<SobelOperatorNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        sobel: typeof sobel;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		sobel: typeof sobel;
+	}
 }

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

@@ -1,33 +1,25 @@
-import { ToneMapping } from "../../constants.js";
-import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ToneMapping } from '../../constants.js';
+import RendererReferenceNode from '../accessors/RendererReferenceNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 // exposure only
 export const LinearToneMappingNode: Node;
 
 export default class ToneMappingNode extends TempNode {
-    toneMapping: ToneMapping;
-    exposureNode: Node;
-    colorNode: Node | null;
+	toneMapping: ToneMapping;
+	exposureNode: Node;
+	colorNode: Node | null;
 
-    constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
+	constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
 }
 
-export const toneMapping: (
-    mapping: ToneMapping,
-    exposure: NodeRepresentation,
-    color?: NodeRepresentation,
-) => ShaderNodeObject<ToneMappingNode>;
+export const toneMapping: (mapping: ToneMapping, exposure: NodeRepresentation, color?: NodeRepresentation) => ShaderNodeObject<ToneMappingNode>;
 export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        toneMapping: (
-            color: NodeRepresentation,
-            mapping?: NodeRepresentation,
-            exposure?: NodeRepresentation,
-        ) => ShaderNodeObject<ToneMappingNode>;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		toneMapping: (color: NodeRepresentation, mapping?: NodeRepresentation, exposure?: NodeRepresentation) => ShaderNodeObject<ToneMappingNode>;
+	}
 }

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

@@ -1,41 +1,27 @@
-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';
 
 declare class TransitionNode extends TempNode {
-    textureNodeA: TextureNode;
-    textureNodeB: TextureNode;
-    mixTextureNode: TextureNode;
+	textureNodeA: TextureNode;
+	textureNodeB: TextureNode;
+	mixTextureNode: TextureNode;
 
-    mixRatioNode: Node;
-    thresholdNode: Node;
-    useTextureNode: Node;
+	mixRatioNode: Node;
+	thresholdNode: Node;
+	useTextureNode: Node;
 
-    constructor(
-        textureNodeA: TextureNode,
-        textureNodeB: TextureNode,
-        mixTextureNode: TextureNode,
-        mixRatioNode: Node,
-        thresholdNode: Node,
-        useTextureNode: Node,
-    );
+	constructor(textureNodeA: TextureNode, textureNodeB: TextureNode, mixTextureNode: TextureNode, mixRatioNode: Node, thresholdNode: Node, useTextureNode: Node);
 }
 
-export const transition: (
-    node: NodeRepresentation,
-    nodeB: NodeRepresentation,
-    mixTexture: NodeRepresentation,
-    mixRatio: UniformNode<number>,
-    threshold: UniformNode<number>,
-    useTexture: UniformNode<number>,
-) => ShaderNodeObject<TransitionNode>;
+export const transition: (node: NodeRepresentation, nodeB: NodeRepresentation, mixTexture: NodeRepresentation, mixRatio: UniformNode<number>, threshold: UniformNode<number>, useTexture: UniformNode<number>) => ShaderNodeObject<TransitionNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        transition: typeof transition;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		transition: typeof transition;
+	}
 }
 
 export default TransitionNode;

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

@@ -1,21 +1,19 @@
-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 ViewportDepthNode extends Node {
-    scope: ViewportDepthNodeScope;
-    valueNode: Node;
+	scope: ViewportDepthNodeScope;
+	valueNode: Node;
 
-    readonly isViewportDepthNode: true;
+	readonly isViewportDepthNode: true;
 
-    constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
+	constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
 
-    static DEPTH: "depth";
-    static LINEAR_DEPTH: "linearDepth";
+	static DEPTH: 'depth';
+	static LINEAR_DEPTH: 'linearDepth';
 }
 
-export type ViewportDepthNodeScope =
-    | typeof ViewportDepthNode.DEPTH
-    | typeof ViewportDepthNode.LINEAR_DEPTH;
+export type ViewportDepthNodeScope = typeof ViewportDepthNode.DEPTH | typeof ViewportDepthNode.LINEAR_DEPTH;
 
 export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
 

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

@@ -1,12 +1,9 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ViewportTextureNode from "./ViewportTextureNode.js";
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ViewportTextureNode from './ViewportTextureNode.js';
 
 export default class ViewportDepthTextureNode extends ViewportTextureNode {
-    constructor(uvNode?: Node, levelNode?: Node | null);
+	constructor(uvNode?: Node, levelNode?: Node | null);
 }
 
-export const viewportDepthTexture: (
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-) => ShaderNodeObject<ViewportDepthTextureNode>;
+export const viewportDepthTexture: (uvNode?: NodeRepresentation, levelNode?: NodeRepresentation) => ShaderNodeObject<ViewportDepthTextureNode>;

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

@@ -1,26 +1,20 @@
-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 type ViewportNodeScope =
-    | typeof ViewportNode.COORDINATE
-    | typeof ViewportNode.RESOLUTION
-    | typeof ViewportNode.TOP_LEFT
-    | typeof ViewportNode.BOTTOM_LEFT
-    | typeof ViewportNode.TOP_RIGHT
-    | typeof ViewportNode.BOTTOM_RIGHT;
+export type ViewportNodeScope = typeof ViewportNode.COORDINATE | typeof ViewportNode.RESOLUTION | typeof ViewportNode.TOP_LEFT | typeof ViewportNode.BOTTOM_LEFT | typeof ViewportNode.TOP_RIGHT | typeof ViewportNode.BOTTOM_RIGHT;
 
 export default class ViewportNode extends Node {
-    static COORDINATE: "coordinate";
-    static RESOLUTION: "resolution";
-    static TOP_LEFT: "topLeft";
-    static BOTTOM_LEFT: "bottomLeft";
-    static TOP_RIGHT: "topRight";
-    static BOTTOM_RIGHT: "bottomRight";
+	static COORDINATE: 'coordinate';
+	static RESOLUTION: 'resolution';
+	static TOP_LEFT: 'topLeft';
+	static BOTTOM_LEFT: 'bottomLeft';
+	static TOP_RIGHT: 'topRight';
+	static BOTTOM_RIGHT: 'bottomRight';
 
-    scope: ViewportNodeScope;
-    isViewportNode: true;
+	scope: ViewportNodeScope;
+	isViewportNode: true;
 
-    constructor(scope: ViewportNodeScope);
+	constructor(scope: ViewportNodeScope);
 }
 
 export const viewportCoordinate: ShaderNodeObject<ViewportNode>;

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

@@ -1,18 +1,15 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ViewportTextureNode from "./ViewportTextureNode.js";
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ViewportTextureNode from './ViewportTextureNode.js';
 
 export default class ViewportSharedTextureNode extends ViewportTextureNode {
-    constructor(uvNode?: Node, levelNode?: Node | null);
+	constructor(uvNode?: Node, levelNode?: Node | null);
 }
 
-export const viewportSharedTexture: (
-    uvNode?: Node,
-    levelNode?: Node | null,
-) => ShaderNodeObject<ViewportSharedTextureNode>;
+export const viewportSharedTexture: (uvNode?: Node, levelNode?: Node | null) => ShaderNodeObject<ViewportSharedTextureNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        viewportSharedTexture: typeof viewportSharedTexture;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		viewportSharedTexture: typeof viewportSharedTexture;
+	}
 }

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

@@ -1,33 +1,25 @@
-import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
-import TextureNode from "../accessors/TextureNode.js";
-import { NodeUpdateType } from "../core/constants.js";
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { FramebufferTexture } from '../../textures/FramebufferTexture.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ViewportTextureNode extends TextureNode {
-    generateMipmaps: boolean;
+	generateMipmaps: boolean;
 
-    readonly isOutputTextureNode: true;
+	readonly isOutputTextureNode: true;
 
-    updateBeforeType: NodeUpdateType;
+	updateBeforeType: NodeUpdateType;
 
-    constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
+	constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
 }
 
-export const viewportTexture: (
-    uvNode?: Node,
-    levelNode?: Node | null,
-    framebufferTexture?: FramebufferTexture | null,
-) => ShaderNodeObject<ViewportTextureNode>;
-export const viewportMipTexture: (
-    uvNode?: Node,
-    levelNode?: Node | null,
-    framebufferTexture?: FramebufferTexture | null,
-) => ShaderNodeObject<Node>;
+export const viewportTexture: (uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null) => ShaderNodeObject<ViewportTextureNode>;
+export const viewportMipTexture: (uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null) => ShaderNodeObject<Node>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        viewportTexture: typeof viewportTexture;
-        viewportMipTexture: typeof viewportMipTexture;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		viewportTexture: typeof viewportTexture;
+		viewportMipTexture: typeof viewportMipTexture;
+	}
 }

package/three/src/nodes/fog/FogExp2Node.d.ts

@@ -1,18 +1,18 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import FogNode from "./FogNode.js";
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import FogNode from './FogNode.js';
 
 export default class FogExp2Node extends FogNode {
-    isFogExp2Node: true;
-    densityNode: Node;
+	isFogExp2Node: true;
+	densityNode: Node;
 
-    constructor(colorNode: Node, densityNode: Node);
+	constructor(colorNode: Node, densityNode: Node);
 }
 
 export const densityFog: (colorNode: Node, densityNode: Node) => ShaderNodeObject<FogExp2Node>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        densityFog: typeof densityFog;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		densityFog: typeof densityFog;
+	}
 }

package/three/src/nodes/fog/FogNode.d.ts

@@ -1,24 +1,21 @@
-import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogNode extends Node {
-    isFogNode: true;
-    colorNode: Node | null;
-    factorNode: Node | null;
+	isFogNode: true;
+	colorNode: Node | null;
+	factorNode: Node | null;
 
-    constructor(colorNode: Node | null, factorNode: Node | null);
+	constructor(colorNode: Node | null, factorNode: Node | null);
 
-    getViewZNode(builder: NodeBuilder): Node;
+	getViewZNode(builder: NodeBuilder): Node;
 }
 
-export const fog: (
-    colorNode: NodeRepresentation | null,
-    factorNode: NodeRepresentation | null,
-) => ShaderNodeObject<FogNode>;
+export const fog: (colorNode: NodeRepresentation | null, factorNode: NodeRepresentation | null) => ShaderNodeObject<FogNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        fog: typeof fog;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		fog: typeof fog;
+	}
 }

package/three/src/nodes/fog/FogRangeNode.d.ts

@@ -1,23 +1,19 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import FogNode from "./FogNode.js";
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import FogNode from './FogNode.js';
 
 export default class FogRangeNode extends FogNode {
-    isFogRangeNode: true;
-    nearNode: Node | null;
-    farNode: Node | null;
+	isFogRangeNode: true;
+	nearNode: Node | null;
+	farNode: Node | null;
 
-    constructor(colorNode: Node | null, nearNode: Node | null, farNode: Node | null);
+	constructor(colorNode: Node | null, nearNode: Node | null, farNode: Node | null);
 }
 
-export const rangeFog: (
-    colorNode: NodeRepresentation | null,
-    nearNode: NodeRepresentation | null,
-    farNode: NodeRepresentation | null,
-) => ShaderNodeObject<FogRangeNode>;
+export const rangeFog: (colorNode: NodeRepresentation | null, nearNode: NodeRepresentation | null, farNode: NodeRepresentation | null) => ShaderNodeObject<FogRangeNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        rangeFog: typeof rangeFog;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rangeFog: typeof rangeFog;
+	}
 }

package/three/src/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -1,15 +1,7 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-declare const BRDF_GGX: (args: {
-    lightDirection: Node;
-    f0: Node;
-    f90: Node;
-    roughness: Node;
-    f?: Node;
-    USE_IRIDESCENCE?: Node;
-    USE_ANISOTROPY?: Node;
-}) => ShaderNodeObject<OperatorNode>;
+declare const BRDF_GGX: (args: { lightDirection: Node; f0: Node; f90: Node; roughness: Node; f?: Node; USE_IRIDESCENCE?: Node; USE_ANISOTROPY?: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default BRDF_GGX;

package/three/src/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -1,6 +1,6 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
 declare const BRDF_Lambert: (args: { diffuseColor: Node }) => ShaderNodeObject<OperatorNode>;
 

package/three/src/nodes/functions/BSDF/BRDF_Sheen.d.ts

@@ -1,6 +1,6 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
 declare const BRDF_Sheen: (args: { lightDirection: Node }) => ShaderNodeObject<OperatorNode>;
 

package/three/src/nodes/functions/BSDF/DFGApprox.d.ts

@@ -1,6 +1,6 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
 // Analytical approximation of the DFG LUT, one half of the
 // split-sum approximation used in indirect specular lighting.

package/three/src/nodes/functions/BSDF/D_GGX.d.ts

@@ -1,6 +1,6 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html

package/three/src/nodes/functions/BSDF/D_GGX_Anisotropic.d.ts

@@ -1,10 +1,8 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
 // https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
-declare const D_GGX_Anisotropic: (
-    args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node },
-) => ShaderNodeObject<OperatorNode>;
+declare const D_GGX_Anisotropic: (args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default D_GGX_Anisotropic;

package/three/src/nodes/functions/BSDF/F_Schlick.d.ts

@@ -1,6 +1,6 @@
-import Node from "../../core/Node.js";
-import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
 declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => ShaderNodeObject<OperatorNode>;
 

package/three/src/nodes/functions/BSDF/LTC.d.ts

@@ -1,9 +1,7 @@
-import Node from "../../core/Node.js";
+import Node from '../../core/Node.js';
 
 declare const LTC_Uv: (args: { N: Node; V: Node; roughness: Node }) => Node;
 
-declare const LTC_Evaluate: (
-    args: { N: Node; V: Node; P: Node; mInv: Node; p0: Node; p1: Node; p2: Node; p3: Node },
-) => Node;
+declare const LTC_Evaluate: (args: { N: Node; V: Node; P: Node; mInv: Node; p0: Node; p1: Node; p2: Node; p3: Node }) => Node;
 
 export { LTC_Evaluate, LTC_Uv };