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

package/three/src/nodes/accessors/SkinningNode.d.ts

@@ -1,19 +1,19 @@
-import { SkinnedMesh } from "../../objects/SkinnedMesh.js";
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { SkinnedMesh } from '../../objects/SkinnedMesh.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SkinningNode extends Node {
-    skinnedMesh: SkinnedMesh;
-    useReference: boolean;
+	skinnedMesh: SkinnedMesh;
+	useReference: boolean;
 
-    skinIndexNode: Node;
-    skinWeightNode: Node;
+	skinIndexNode: Node;
+	skinWeightNode: Node;
 
-    bindMatrixNode: Node;
-    bindMatrixInverseNode: Node;
-    boneMatricesNode: Node;
+	bindMatrixNode: Node;
+	bindMatrixInverseNode: Node;
+	boneMatricesNode: Node;
 
-    constructor(skinnedMesh: SkinnedMesh, useReference?: boolean);
+	constructor(skinnedMesh: SkinnedMesh, useReference?: boolean);
 }
 
 export const skinning: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;

package/three/src/nodes/accessors/StorageBufferNode.d.ts

@@ -1,38 +1,26 @@
-import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
-import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
-import { GPUBufferBindingType } from "../../renderers/webgpu/utils/WebGPUConstants.js";
-import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import StorageArrayElementNode from "../utils/StoargeArrayElementNode.js";
-import BufferNode from "./BufferNode.js";
+import StorageBufferAttribute from '../../renderers/common/StorageBufferAttribute.js';
+import StorageInstancedBufferAttribute from '../../renderers/common/StorageInstancedBufferAttribute.js';
+import { GPUBufferBindingType } from '../../renderers/webgpu/utils/WebGPUConstants.js';
+import { NodeOrType, NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import StorageArrayElementNode from '../utils/StoargeArrayElementNode.js';
+import BufferNode from './BufferNode.js';
 
 export default class StorageBufferNode extends BufferNode {
-    readonly isStorageBufferNode: true;
-    bufferObject: boolean;
+	readonly isStorageBufferNode: true;
+	bufferObject: boolean;
 
-    access: GPUBufferBindingType;
+	access: GPUBufferBindingType;
 
-    constructor(
-        value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-        bufferType: string,
-        bufferCount?: number,
-    );
+	constructor(value: StorageBufferAttribute | StorageInstancedBufferAttribute, bufferType: string, bufferCount?: number);
 
-    element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
+	element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
 
-    setBufferObject(value: boolean): this;
+	setBufferObject(value: boolean): this;
 
-    setAccess(value: GPUBufferBindingType): this;
+	setAccess(value: GPUBufferBindingType): this;
 
-    toReadOnly(): this;
+	toReadOnly(): this;
 }
 
-export const storage: (
-    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    nodeOrType: NodeOrType,
-    count: number,
-) => ShaderNodeObject<StorageBufferNode>;
-export const storageObject: (
-    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    nodeOrType: NodeOrType,
-    count: number,
-) => ShaderNodeObject<StorageBufferNode>;
+export const storage: (value: StorageBufferAttribute | StorageInstancedBufferAttribute, nodeOrType: NodeOrType, count: number) => ShaderNodeObject<StorageBufferNode>;
+export const storageObject: (value: StorageBufferAttribute | StorageInstancedBufferAttribute, nodeOrType: NodeOrType, count: number) => ShaderNodeObject<StorageBufferNode>;

package/three/src/nodes/accessors/StorageTextureNode.d.ts

@@ -1,40 +1,28 @@
-import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
-import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import TextureNode from "./TextureNode.js";
+import { GPUStorageTextureAccess } from '../../renderers/webgpu/utils/WebGPUConstants.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TextureNode from './TextureNode.js';
 
 export default class StorageTextureNode extends TextureNode {
-    storeNode: Node | null;
+	storeNode: Node | null;
 
-    readonly isStorageTextureNode: true;
+	readonly isStorageTextureNode: true;
 
-    access: GPUStorageTextureAccess;
+	access: GPUStorageTextureAccess;
 
-    constructor(
-        value: Texture,
-        uvNode?: ShaderNodeObject<Node> | null,
-        storeNode?: Node | null,
-    );
+	constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, storeNode?: Node | null);
 
-    setAccess(value: GPUStorageTextureAccess): this;
+	setAccess(value: GPUStorageTextureAccess): this;
 
-    toReadOnly(): this;
+	toReadOnly(): this;
 
-    toWriteOnly(): this;
+	toWriteOnly(): this;
 
-    generateStore(builder: NodeBuilder): void;
+	generateStore(builder: NodeBuilder): void;
 }
 
-export const storageTexture: (
-    value: Texture,
-    uvNode?: NodeRepresentation,
-    storeNode?: NodeRepresentation,
-) => ShaderNodeObject<StorageTextureNode>;
-
-export const textureStore: (
-    value: Texture,
-    uvNode?: NodeRepresentation,
-    storeNode?: NodeRepresentation,
-) => ShaderNodeObject<StorageTextureNode>;
+export const storageTexture: (value: Texture, uvNode?: NodeRepresentation, storeNode?: NodeRepresentation) => ShaderNodeObject<StorageTextureNode>;
+
+export const textureStore: (value: Texture, uvNode?: NodeRepresentation, storeNode?: NodeRepresentation) => ShaderNodeObject<StorageTextureNode>;

package/three/src/nodes/accessors/TangentNode.d.ts

@@ -1,8 +1,8 @@
-import AttributeNode from "../core/AttributeNode.js";
-import VarNode from "../core/VarNode.js";
-import VaryingNode from "../core/VaryingNode.js";
-import MathNode from "../math/MathNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import AttributeNode from '../core/AttributeNode.js';
+import VarNode from '../core/VarNode.js';
+import VaryingNode from '../core/VaryingNode.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export const tangentGeometry: ShaderNodeObject<AttributeNode>;
 export const tangentLocal: ShaderNodeObject<VaryingNode>;

package/three/src/nodes/accessors/Texture3DNode.d.ts

@@ -1,17 +1,13 @@
-import { CubeTexture } from "../../textures/CubeTexture.js";
-import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import TextureNode from "./TextureNode.js";
+import { CubeTexture } from '../../textures/CubeTexture.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TextureNode from './TextureNode.js';
 
 export default class Texture3DNode extends TextureNode {
-    readonly isTexture3DNode: true;
+	readonly isTexture3DNode: true;
 
-    constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+	constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
 }
 
-export const texture3D: (
-    value: Texture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-) => ShaderNodeObject<Texture3DNode>;
+export const texture3D: (value: Texture, uvNode?: NodeRepresentation, levelNode?: NodeRepresentation) => ShaderNodeObject<Texture3DNode>;

package/three/src/nodes/accessors/TextureBicubicNode.d.ts

@@ -1,18 +1,18 @@
-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 default class TextureBicubicNode extends TempNode {
-    textureNode: Node;
-    blurNode: Node;
+	textureNode: Node;
+	blurNode: Node;
 
-    constructor(textureNode: Node, blurNode?: Node);
+	constructor(textureNode: Node, blurNode?: Node);
 }
 
 export const textureBicubic: (textureNode: Node, blurNode?: NodeRepresentation) => ShaderNodeObject<TextureBicubicNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        bicubic: typeof textureBicubic;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		bicubic: typeof textureBicubic;
+	}
 }

package/three/src/nodes/accessors/TextureNode.d.ts

@@ -1,47 +1,37 @@
-import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class TextureNode extends UniformNode<Texture> {
-    readonly isTextureNode: true;
+	readonly isTextureNode: true;
 
-    uvNode: ShaderNodeObject<Node> | null;
-    levelNode: ShaderNodeObject<Node> | null;
-    biasNode: ShaderNodeObject<Node> | null;
-    compareNode: Node | null;
-    depthNode: Node | null;
-    gradNode: Node | null;
+	uvNode: ShaderNodeObject<Node> | null;
+	levelNode: ShaderNodeObject<Node> | null;
+	biasNode: ShaderNodeObject<Node> | null;
+	compareNode: Node | null;
+	depthNode: Node | null;
+	gradNode: Node | null;
 
-    sampler: boolean;
-    updateMatrix: boolean;
+	sampler: boolean;
+	updateMatrix: boolean;
 
-    referenceNode: Node | null;
+	referenceNode: Node | null;
 
-    constructor(
-        value: Texture,
-        uvNode?: ShaderNodeObject<Node> | null,
-        levelNode?: ShaderNodeObject<Node> | null,
-        biasNode?: ShaderNodeObject<Node> | null,
-    );
+	constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null, biasNode?: ShaderNodeObject<Node> | null);
 
-    getDefaultUV(): Node;
+	getDefaultUV(): Node;
 
-    grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
+	grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
 
-    clone(): this;
+	clone(): this;
 }
 
-export const texture: (
-    value: Texture,
-    uvNode?: NodeRepresentation,
-    levelNode?: NodeRepresentation,
-    biasNode?: NodeRepresentation,
-) => ShaderNodeObject<TextureNode>;
+export const texture: (value: Texture, uvNode?: NodeRepresentation, levelNode?: NodeRepresentation, biasNode?: NodeRepresentation) => ShaderNodeObject<TextureNode>;
 export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        texture: typeof texture;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		texture: typeof texture;
+	}
 }

package/three/src/nodes/accessors/UVNode.d.ts

@@ -1,4 +1,4 @@
-import AttributeNode from "../core/AttributeNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export const uv: (index?: number) => ShaderNodeObject<AttributeNode>;

package/three/src/nodes/accessors/UniformsNode.d.ts

@@ -1,23 +1,23 @@
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ArrayElementNode from "../utils/ArrayElementNode.js";
-import BufferNode from "./BufferNode.js";
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ArrayElementNode from '../utils/ArrayElementNode.js';
+import BufferNode from './BufferNode.js';
 
 declare class UniformsElementNode extends ArrayElementNode {
-    constructor(arrayBuffer: Node, indexNode: Node);
+	constructor(arrayBuffer: Node, indexNode: Node);
 }
 
 export default class UniformsNode extends BufferNode {
-    array: unknown[];
-    elementType: string | null;
+	array: unknown[];
+	elementType: string | null;
 
-    readonly isArrayBufferNode: true;
+	readonly isArrayBufferNode: true;
 
-    constructor(value: unknown[], elementType?: string | null);
+	constructor(value: unknown[], elementType?: string | null);
 
-    getElementLength(): number;
+	getElementLength(): number;
 
-    element(indexNode: number): ShaderNodeObject<UniformsElementNode>;
+	element(indexNode: number): ShaderNodeObject<UniformsElementNode>;
 }
 
 export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformsNode>;

package/three/src/nodes/accessors/UserDataNode.d.ts

@@ -1,15 +1,11 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ReferenceNode from "./ReferenceNode.js";
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ReferenceNode from './ReferenceNode.js';
 
 export type NodeUserData = Record<string, any>;
 
 export default class UserDataNode extends ReferenceNode<NodeUserData> {
-    userData: NodeUserData | null;
-    constructor(property: string, inputType: string, userData?: NodeUserData | null);
+	userData: NodeUserData | null;
+	constructor(property: string, inputType: string, userData?: NodeUserData | null);
 }
 
-export const userData: (
-    name: string,
-    inputType: string,
-    userData?: NodeUserData,
-) => ShaderNodeObject<UserDataNode>;
+export const userData: (name: string, inputType: string, userData?: NodeUserData) => ShaderNodeObject<UserDataNode>;

package/three/src/nodes/accessors/VertexColorNode.d.ts

@@ -1,12 +1,12 @@
-import AttributeNode from "../core/AttributeNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VertexColorNode extends AttributeNode {
-    readonly isVertexColorNode: true;
+	readonly isVertexColorNode: true;
 
-    index: number;
+	index: number;
 
-    constructor(index?: number);
+	constructor(index?: number);
 }
 
 export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;

package/three/src/nodes/code/CodeNode.d.ts

@@ -1,20 +1,20 @@
-import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface CodeNodeInclude {
-    build(builder: NodeBuilder): void;
+	build(builder: NodeBuilder): void;
 }
 
 export default class CodeNode extends Node {
-    isCodeNode: true;
-    code: string;
-    language: string;
+	isCodeNode: true;
+	code: string;
+	language: string;
 
-    constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
+	constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
 
-    setIncludes(includes: CodeNodeInclude[]): this;
-    getIncludes(builder: NodeBuilder): CodeNodeInclude[];
+	setIncludes(includes: CodeNodeInclude[]): this;
+	getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
 
 export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => ShaderNodeObject<CodeNode>;

package/three/src/nodes/code/ExpressionNode.d.ts

@@ -1,9 +1,9 @@
-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 ExpressionNode extends TempNode {
-    snipped: string; /* sic */
-    constructor(snipped?: string, nodeType?: string);
+	snipped: string; /* sic */
+	constructor(snipped?: string, nodeType?: string);
 }
 
 export const expression: (snipped?: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;

package/three/src/nodes/code/FunctionCallNode.d.ts

@@ -1,25 +1,22 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { ProxiedObject, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import FunctionNode, { FunctionNodeArguments } from "./FunctionNode.js";
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { ProxiedObject, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import FunctionNode, { FunctionNodeArguments } from './FunctionNode.js';
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
-    functionNode: FunctionNode<P>;
-    parameters: { [name: string]: Node };
+	functionNode: FunctionNode<P>;
+	parameters: { [name: string]: Node };
 
-    constructor(functionNode?: FunctionNode<P>, parameters?: P);
+	constructor(functionNode?: FunctionNode<P>, parameters?: P);
 
-    setParameters(parameters: P): this;
-    getParameters(): P;
+	setParameters(parameters: P): this;
+	getParameters(): P;
 }
 
-export const call: <P extends FunctionNodeArguments>(
-    functionNode?: FunctionNode<P>,
-    parameters?: ProxiedObject<P>,
-) => ShaderNodeObject<FunctionCallNode<P>>;
+export const call: <P extends FunctionNodeArguments>(functionNode?: FunctionNode<P>, parameters?: ProxiedObject<P>) => ShaderNodeObject<FunctionCallNode<P>>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        call: typeof call;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		call: typeof call;
+	}
 }

package/three/src/nodes/code/FunctionNode.d.ts

@@ -1,39 +1,38 @@
-import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import NodeFunction from "../core/NodeFunction.js";
-import NodeFunctionInput from "../core/NodeFunctionInput.js";
-import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import CodeNode, { CodeNodeInclude } from "./CodeNode.js";
-import FunctionCallNode from "./FunctionCallNode.js";
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import NodeFunction from '../core/NodeFunction.js';
+import NodeFunctionInput from '../core/NodeFunctionInput.js';
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import CodeNode, { CodeNodeInclude } from './CodeNode.js';
+import FunctionCallNode from './FunctionCallNode.js';
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
 export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
-    keywords: { [key: string]: Node };
-    constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
+	keywords: { [key: string]: Node };
+	constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
 
-    getInputs(builder: NodeBuilder): NodeFunctionInput[];
-    getNodeFunction(builder: NodeBuilder): NodeFunction;
-    call(parameters: P): FunctionCallNode<P>;
+	getInputs(builder: NodeBuilder): NodeFunctionInput[];
+	getNodeFunction(builder: NodeBuilder): NodeFunction;
+	call(parameters: P): FunctionCallNode<P>;
 }
 
-export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
-    : readonly [ProxiedObject<P>];
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P> : readonly [ProxiedObject<P>];
 
 export const nativeFn: <P extends FunctionNodeArguments>(
-    code: string,
-    includes?: CodeNodeInclude[],
-    language?: string,
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	code: string,
+	includes?: CodeNodeInclude[],
+	language?: string
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 ) => (...params: Fn<P>) => ShaderNodeObject<Node>;
 
 export const glslFn: <P extends FunctionNodeArguments>(
-    code: string,
-    includes?: CodeNodeInclude[],
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	code: string,
+	includes?: CodeNodeInclude[]
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 ) => (...params: Fn<P>) => ShaderNodeObject<Node>;
 export const wgslFn: <P extends FunctionNodeArguments>(
-    code: string,
-    includes?: CodeNodeInclude[],
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+	code: string,
+	includes?: CodeNodeInclude[]
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 ) => (...params: Fn<P>) => ShaderNodeObject<Node>;

package/three/src/nodes/core/AssignNode.d.ts

@@ -1,18 +1,18 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
-import TempNode from "./TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import TempNode from './TempNode.js';
 
 export default class AssignNode extends TempNode {
-    constructor(targetNode: Node, sourceNode: Node);
+	constructor(targetNode: Node, sourceNode: Node);
 
-    needsSplitAssign(builder: NodeBuilder): boolean;
+	needsSplitAssign(builder: NodeBuilder): boolean;
 }
 
 export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        assign: typeof assign;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		assign: typeof assign;
+	}
 }

package/three/src/nodes/core/AttributeNode.d.ts

@@ -1,19 +1,15 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
 
 export default class AttributeNode extends Node {
-    defaultNode: Node | null;
+	defaultNode: Node | null;
 
-    constructor(attributeName: string, nodeType?: string | null, defaultNode?: Node | null);
+	constructor(attributeName: string, nodeType?: string | null, defaultNode?: Node | null);
 
-    setAttributeName(attributeName: string): this;
+	setAttributeName(attributeName: string): this;
 
-    getAttributeName(builder: NodeBuilder): string;
+	getAttributeName(builder: NodeBuilder): string;
 }
 
-export const attribute: (
-    name: string,
-    nodeType?: string | null,
-    defaultNode?: NodeRepresentation,
-) => ShaderNodeObject<AttributeNode>;
+export const attribute: (name: string, nodeType?: string | null, defaultNode?: NodeRepresentation) => ShaderNodeObject<AttributeNode>;

package/three/src/nodes/core/BypassNode.d.ts

@@ -1,18 +1,18 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
 
 export default class BypassNode extends Node {
-    isBypassNode: true;
-    outputNode: Node;
-    callNode: Node;
+	isBypassNode: true;
+	outputNode: Node;
+	callNode: Node;
 
-    constructor(returnNode: Node, callNode: Node);
+	constructor(returnNode: Node, callNode: Node);
 }
 
 export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        bypass: typeof bypass;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		bypass: typeof bypass;
+	}
 }