@nativescript/canvas-three 2.0.0-webgpu.3 → 2.0.0-webgpu.31

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

@@ -0,0 +1,117 @@
+import { EventDispatcher } from '../../core/EventDispatcher.js';
+import { NodeUpdateType } from './constants.js';
+import NodeBuilder from './NodeBuilder.js';
+import NodeFrame from './NodeFrame.js';
+interface NodeJSONMeta {
+	textures: {
+		[key: string]: unknown;
+	};
+	images: {
+		[key: string]: unknown;
+	};
+	nodes: {
+		[key: string]: NodeJSONIntermediateOutputData;
+	};
+}
+interface NodeJSONMetadata {
+	version: number;
+	type: 'Node';
+	generator: 'Node.toJSON';
+}
+interface NodeJSONInputNodes {
+	[property: string]:
+		| string[]
+		| {
+				[index: string]: string | undefined;
+		  }
+		| string
+		| undefined;
+}
+export interface NodeJSONInputData {
+	inputNodes?: NodeJSONInputNodes | undefined;
+	meta: {
+		textures: {
+			[key: string]: unknown;
+		};
+		nodes: {
+			[key: string]: Node;
+		};
+	};
+}
+export interface NodeJSONIntermediateOutputData {
+	uuid: string;
+	type: string | undefined;
+	meta?: NodeJSONMeta | undefined;
+	metadata?: NodeJSONMetadata;
+	inputNodes?: NodeJSONInputNodes | undefined;
+	textures?: unknown[];
+	images?: unknown[];
+	nodes?: NodeJSONIntermediateOutputData[];
+}
+interface NodeJSONOutputData {
+	uuid: string;
+	type: string | undefined;
+	metadata?: NodeJSONMetadata;
+	inputNodes?: NodeJSONInputNodes | undefined;
+	textures?: unknown[];
+	images?: unknown[];
+	nodes?: NodeJSONOutputData[];
+}
+declare class Node extends EventDispatcher<{
+	dispose: {};
+}> {
+	nodeType: string | null;
+	updateType: NodeUpdateType;
+	updateBeforeType: NodeUpdateType;
+	updateAfterType: NodeUpdateType;
+	uuid: string;
+	version: number;
+	_cacheKey: string | null;
+	_cacheKeyVersion: number;
+	global: boolean;
+	readonly isNode: true;
+	readonly id: number;
+	self?: this;
+	constructor(nodeType?: string | null);
+	set needsUpdate(value: boolean);
+	get type(): string | undefined;
+	onUpdate(callback: (this: this, frame: NodeFrame) => unknown, updateType: NodeUpdateType): this;
+	onFrameUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+	onRenderUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+	onObjectUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+	onReference(callback: (this: this, frame: NodeBuilder | NodeFrame) => unknown): this;
+	getSelf(): this;
+	updateReference(state: NodeBuilder | NodeFrame): unknown;
+	isGlobal(builder: NodeBuilder): boolean;
+	getChildren(): Generator<Node, void, unknown>;
+	dispose(): void;
+	traverse(callback: (node: Node) => void): void;
+	getCacheKey(force?: boolean): string;
+	getHash(builder: NodeBuilder): string;
+	getUpdateType(): NodeUpdateType;
+	getUpdateBeforeType(): NodeUpdateType;
+	getUpdateAfterType(): NodeUpdateType;
+	getElementType(builder: NodeBuilder): 'bool' | 'int' | 'float' | 'vec2' | 'vec3' | 'vec4' | 'uint' | null;
+	getNodeType(builder: NodeBuilder): string | null;
+	getShared(builder: NodeBuilder): Node;
+	setup(builder: NodeBuilder): unknown;
+	increaseUsage(builder: NodeBuilder): number;
+	analyze(builder: NodeBuilder): void;
+	generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
+	updateBefore(frame: NodeFrame): void;
+	updateAfter(frame: NodeFrame): void;
+	update(frame: NodeFrame): void;
+	build(builder: NodeBuilder, output?: string | null): string | null;
+	getSerializeChildren(): Generator<import('./NodeUtils.js').NodeChild, void, unknown>;
+	serialize(json: NodeJSONIntermediateOutputData): void;
+	deserialize(json: NodeJSONInputData): void;
+	toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData;
+}
+export default Node;
+export declare function addNodeClass(
+	type: string,
+	nodeClass: {
+		new (...args: any[]): Node;
+	}
+): void;
+export declare function createNodeFromType(type: string): Node | undefined;

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

@@ -0,0 +1,9 @@
+import Node from './Node.js';
+declare class NodeAttribute {
+	readonly isNodeAttribute: true;
+	name: string;
+	type: string | null;
+	node: Node | null;
+	constructor(name: string, type: string | null, node?: Node | null);
+}
+export default NodeAttribute;

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

@@ -0,0 +1,133 @@
+import { BufferGeometry } from '../../core/BufferGeometry.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Material } from '../../materials/Material.js';
+import Renderer from '../../renderers/common/Renderer.js';
+import { Texture } from '../../textures/Texture.js';
+import FogNode from '../fog/FogNode.js';
+import LightsNode from '../lighting/LightsNode.js';
+import { NodeShaderStage } from './constants.js';
+import Node from './Node.js';
+import NodeAttribute from './NodeAttribute.js';
+import NodeCache from './NodeCache.js';
+import NodeParser from './NodeParser.js';
+import NodeUniform from './NodeUniform.js';
+import NodeVar from './NodeVar.js';
+import NodeVarying from './NodeVarying.js';
+import StackNode from './StackNode.js';
+
+export type BuildStageOption = 'construct' | 'analyze' | 'generate';
+
+export interface FlowData {
+	code: string;
+}
+
+export interface NodeData {
+	vertex: { [key: string]: unknown };
+	fragment: { [key: string]: unknown };
+	compute: { [key: string]: unknown };
+}
+
+export type NodeBuilderContext = { [key: string]: unknown };
+
+export default abstract class NodeBuilder {
+	object: Object3D;
+	material: Material;
+	geometry: BufferGeometry;
+	renderer: Renderer;
+	parser: NodeParser;
+
+	nodes: Node[];
+	updateNodes: Node[];
+	hashNodes: { [hash: string]: Node };
+
+	lightsNode: LightsNode;
+	fogNode: FogNode;
+
+	vertexShader: string;
+	fragmentShader: string;
+	computeShader: string;
+
+	cache: NodeCache;
+	globalCache: NodeCache;
+
+	/**
+	 * @TODO used to be missing. check the actual type later
+	 */
+	flowsData: any;
+
+	shaderStage: NodeShaderStage | null;
+	buildStage: BuildStageOption | null;
+	stack: StackNode;
+
+	setHashNode(node: Node, hash: string): void;
+	addNode(node: Node): void;
+	get currentNode(): Node;
+	isFilteredTexture(texture: Texture): boolean;
+	getMethod(method: string): string;
+	getNodeFromHash(hash: string): Node;
+
+	addFlow(shaderStage: NodeShaderStage, node: Node): Node;
+
+	setContext(context: NodeBuilderContext): void;
+	getContext(): NodeBuilderContext;
+	setCache(cache: NodeCache): void;
+	getCache(): NodeCache;
+	getCacheFromNode(node: Node, parent?: boolean): NodeCache;
+	isAvailable(name: string): boolean;
+
+	abstract getInstanceIndex(): string;
+
+	abstract getDrawIndex(): string | null;
+
+	abstract getFrontFacing(): string;
+
+	abstract getFragCoord(): string;
+
+	isFlipY(): boolean;
+
+	// @TODO: rename to .generateConst()
+	getConst(type: string, value?: unknown): Node;
+	getType(type: string): string;
+
+	generateMethod(method: string): string;
+
+	getAttribute(name: string, type: string): NodeAttribute;
+
+	getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+	isVector(type: string): boolean;
+
+	isMatrix(type: string): boolean;
+	isReference(type: string): boolean;
+	getElementType(type: string): string | null;
+	getComponentType(type: string): string | null;
+	getVectorType(type: string): string;
+	getTypeFromLength(length: number): string;
+	getTypeLength(type: string): number;
+	getVectorFromMatrix(type: string): string;
+	getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
+	getNodeProperties(node: Node, shaderStage?: NodeShaderStage): { [key: string]: unknown };
+	getUniformFromNode(node: Node, type: string, shaderStage?: NodeShaderStage, name?: string | null): NodeUniform<string>;
+	getVarFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): NodeVar;
+	getVaryFromNode(node: Node, type: string): NodeVarying;
+	getCodeFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): string;
+	addFlowCode(code: string): void;
+	getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
+	flowNode(node: Node): FlowData;
+	flowChildNode(node: Node, output?: string | null): FlowData;
+	flowNodeFromShaderStage(shaderStage: NodeShaderStage, node: Node, output?: string | null, propertyName?: string): FlowData;
+	hasGeometryAttribute(name: string): boolean;
+	abstract getAttributes(shaderStage: NodeShaderStage): string;
+	abstract getVaryings(shaderStage: NodeShaderStage): string;
+	getVars(shaderStage: NodeShaderStage): string;
+	abstract getUniforms(stage: NodeShaderStage): string;
+	getCodes(shaderStage: NodeShaderStage): string;
+	getHash(): string;
+	setShaderStage(shaderStage: NodeShaderStage): void;
+	getShaderStage(): NodeShaderStage;
+	setBuildStage(buildStage: BuildStageOption): void;
+	getBuildStage(): BuildStageOption;
+	abstract buildCode(): void;
+	build(): this;
+	format(snippet: string, fromType: string, toType: string): string;
+	getSignature(): string;
+}

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

@@ -0,0 +1,49 @@
+import { BufferAttribute, TypedArray } from '../../core/BufferAttribute.js';
+import { InterleavedBuffer } from '../../core/InterleavedBuffer.js';
+import BufferAttributeNode from '../accessors/BufferAttributeNode.js';
+import Node from './Node.js';
+import NodeAttribute from './NodeAttribute.js';
+import NodeCode from './NodeCode.js';
+import NodeUniform from './NodeUniform.js';
+import NodeVar from './NodeVar.js';
+import NodeVarying from './NodeVarying.js';
+export interface ShaderStageNodeData {
+	properties?:
+		| ({
+				outputNode: Node | null;
+				initialized?: boolean | undefined;
+		  } & {
+				[K in `node${string}`]?: Node | undefined;
+		  })
+		| undefined;
+	bufferAttribute?: NodeAttribute | undefined;
+	structType?: Node | undefined;
+	uniform?: NodeUniform<unknown> | undefined;
+	variable?: NodeVar | undefined;
+	varying?: NodeVarying | undefined;
+	code?: NodeCode | undefined;
+	usageCount?: number | undefined;
+	snippet?: string | undefined;
+	propertyName?: string | undefined;
+	propertySizeName?: string | undefined;
+}
+interface NodeData {
+	vertex?: ShaderStageNodeData | undefined;
+	fragment?: ShaderStageNodeData | undefined;
+	compute?: ShaderStageNodeData | undefined;
+	any?: ShaderStageNodeData | undefined;
+}
+interface BufferAttributeData {
+	node: BufferAttributeNode;
+}
+declare class NodeCache {
+	id: number;
+	nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
+	parent: NodeCache | null;
+	constructor(parent?: NodeCache | null);
+	getData(node: Node): NodeData | undefined;
+	getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+	setData(node: Node, data: NodeData): void;
+	setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
+}
+export default NodeCache;

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

@@ -0,0 +1,4 @@
+export default class NodeCode {
+	isNodeCode: true;
+	constructor(name: string, type: string, code?: string);
+}

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

@@ -0,0 +1,34 @@
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Material } from '../../materials/Material.js';
+import Renderer from '../../renderers/common/Renderer.js';
+import { Scene } from '../../scenes/Scene.js';
+import Node from './Node.js';
+
+export default class NodeFrame {
+	time: number;
+	deltaTime: number;
+
+	frameId: number;
+	renderId: number;
+
+	startTime: number | null;
+
+	frameMap: WeakMap<Node, number>;
+	frameBeforeMap: WeakMap<Node, number>;
+	renderMap: WeakMap<Node, number>;
+	renderBeforeMap: WeakMap<Node, number>;
+
+	renderer: Renderer | null;
+	material: Material | null;
+	camera: Camera | null;
+	object: Object3D | null;
+	scene: Scene | null;
+
+	constructor();
+
+	updateBeforeNode(node: Node): void;
+
+	updateNode(node: Node): void;
+	update(): void;
+}

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

@@ -0,0 +1,13 @@
+import NodeFunctionInput from './NodeFunctionInput.js';
+
+export default abstract class NodeFunction {
+	isNodeFunction: true;
+	type: string;
+	inputs: NodeFunctionInput[];
+	name: string;
+	precision: string;
+
+	constructor(type: string, inputs: NodeFunctionInput[], name?: string, precision?: string);
+
+	abstract getCode(name?: string): string;
+}

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

@@ -0,0 +1,7 @@
+export default class NodeFunctionInput {
+	isNodeFunctionInput: true;
+	count: null | number;
+	qualifier: string;
+	isConst: boolean;
+	constructor(type: string, name: string, count?: number, qualifier?: string, isConst?: boolean);
+}

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

@@ -0,0 +1,17 @@
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+declare class NodeKeywords {
+	keywords: string[];
+	nodes: {
+		[name: string]: Node;
+	};
+	keywordsCallback: {
+		[name: string]: (name: string) => Node;
+	};
+	constructor();
+	getNode(name: string): Node;
+	addKeyword(name: string, callback: (name: string) => Node): this;
+	parse(code: string): Node[];
+	include(builder: NodeBuilder, code: string): void;
+}
+export default NodeKeywords;

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

@@ -0,0 +1,5 @@
+import NodeFunction from './NodeFunction.js';
+declare abstract class NodeParser {
+	abstract parseFunction(source: string): NodeFunction;
+}
+export default NodeParser;

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

@@ -0,0 +1,14 @@
+import UniformNode from './UniformNode.js';
+declare class NodeUniform<TValue> {
+	readonly isNodeUniform: true;
+	name: string;
+	type: string | null;
+	node: UniformNode<TValue>;
+	needsUpdate: boolean | undefined;
+	constructor(name: string, type: string | null, node: UniformNode<TValue>);
+	get value(): TValue;
+	set value(val: TValue);
+	get id(): number;
+	get groupNode(): import('./UniformGroupNode.js').default;
+}
+export default NodeUniform;

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

@@ -0,0 +1,18 @@
+import { Color } from '../../math/Color.js';
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { Vector4 } from '../../math/Vector4.js';
+import Node from './Node.js';
+
+export interface NodeChild {
+	property: string;
+	index?: number | string;
+	childNode: Node;
+}
+
+export function getCacheKey(object: Node, force?: boolean): string;
+export function getNodeChildren(object: Node): Generator<NodeChild, void>;
+export function getValueType(value: unknown): string | null;
+export function getValueFromType(type: string, ...params: number[]): Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number | string | ArrayBufferLike | null;

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

@@ -0,0 +1,7 @@
+declare class NodeVar {
+	readonly isNodeVar: true;
+	name: string;
+	type: string | null;
+	constructor(name: string, type: string | null);
+}
+export default NodeVar;

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

@@ -0,0 +1,7 @@
+import NodeVar from './NodeVar.js';
+declare class NodeVarying extends NodeVar {
+	needsInterpolation: boolean;
+	readonly isNodeVarying: true;
+	constructor(name: string, type: string | null);
+}
+export default NodeVarying;

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

@@ -0,0 +1,12 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+
+export default class OutputStructNode extends Node {
+	members: Node[];
+
+	readonly isOutputStructNode: true;
+
+	constructor(...members: Node[]);
+}
+
+export const outputStruct: (...members: Node[]) => ShaderNodeObject<OutputStructNode>;

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

@@ -0,0 +1,43 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+
+export default class PropertyNode extends Node {
+	name: string | null;
+	varying: boolean;
+
+	readonly isPropertyNode: true;
+
+	constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
+}
+
+export const property: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+
+export const diffuseColor: ShaderNodeObject<PropertyNode>;
+export const emissive: ShaderNodeObject<PropertyNode>;
+export const roughness: ShaderNodeObject<PropertyNode>;
+export const metalness: ShaderNodeObject<PropertyNode>;
+export const clearcoat: ShaderNodeObject<PropertyNode>;
+export const clearcoatRoughness: ShaderNodeObject<PropertyNode>;
+export const sheen: ShaderNodeObject<PropertyNode>;
+export const sheenRoughness: ShaderNodeObject<PropertyNode>;
+export const iridescence: ShaderNodeObject<PropertyNode>;
+export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
+export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
+export const alphaT: ShaderNodeObject<PropertyNode>;
+export const anisotropy: ShaderNodeObject<PropertyNode>;
+export const anisotropyT: ShaderNodeObject<PropertyNode>;
+export const anisotropyB: ShaderNodeObject<PropertyNode>;
+export const specularColor: ShaderNodeObject<PropertyNode>;
+export const specularF90: ShaderNodeObject<PropertyNode>;
+export const shininess: ShaderNodeObject<PropertyNode>;
+export const output: ShaderNodeObject<PropertyNode>;
+export const dashSize: ShaderNodeObject<PropertyNode>;
+export const gapSize: ShaderNodeObject<PropertyNode>;
+export const pointWidth: ShaderNodeObject<PropertyNode>;
+export const ior: ShaderNodeObject<PropertyNode>;
+export const transmission: ShaderNodeObject<PropertyNode>;
+export const thickness: ShaderNodeObject<PropertyNode>;
+export const attenuationDistance: ShaderNodeObject<PropertyNode>;
+export const attenuationColor: ShaderNodeObject<PropertyNode>;
+export const dispersion: ShaderNodeObject<PropertyNode>;

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

@@ -0,0 +1,17 @@
+import Node from './Node.js';
+
+export default class StackNode extends Node {
+	isStackNode: true;
+	nodes: Node[];
+	outputNode: Node | null;
+
+	constructor();
+
+	add(node: Node): this;
+
+	if(boolNode: Node, method: () => void): this;
+
+	elseIf(node: Node, method: () => void): this;
+
+	else(node: Node, method: () => void): this;
+}

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

@@ -0,0 +1,8 @@
+import Node from './Node.js';
+declare class StructTypeNode extends Node {
+	types: string[];
+	readonly isStructTypeNode: true;
+	constructor(types: string[]);
+	getMemberTypes(): string[];
+}
+export default StructTypeNode;

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

@@ -0,0 +1,10 @@
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+
+export default class TempNode extends Node {
+	isTempNode: true;
+
+	constructor(type: string | null);
+
+	hasDependencies(builder: NodeBuilder): boolean;
+}

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

@@ -0,0 +1,7 @@
+export default class UniformGroup {
+	name: string;
+
+	readonly isUniformGroup: true;
+
+	constructor(name: string);
+}

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

@@ -0,0 +1,21 @@
+import Node from './Node.js';
+
+export default class UniformGroupNode extends Node {
+	name: string;
+	version: number;
+
+	shared: boolean;
+
+	readonly isUniformGroup: true;
+
+	constructor(name: string, shared?: boolean);
+
+	set needsUpdate(value: boolean);
+}
+
+export const uniformGroup: (name: string) => UniformGroupNode;
+export const sharedUniformGroup: (name: string) => UniformGroupNode;
+
+export const frameGroup: UniformGroupNode;
+export const renderGroup: UniformGroupNode;
+export const objectGroup: UniformGroupNode;

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

@@ -0,0 +1,20 @@
+import { NodeUpdateType } from './constants.js';
+import InputNode from './InputNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import NodeFrame from './NodeFrame.js';
+import UniformGroupNode from './UniformGroupNode.js';
+declare class UniformNode<TValue> extends InputNode<TValue> {
+	readonly isUniformNode: true;
+	name: string;
+	groupNode: UniformGroupNode;
+	constructor(value: TValue, nodeType?: string | null);
+	label(name: string): this;
+	setGroup(group: UniformGroupNode): this;
+	getGroup(): UniformGroupNode;
+	getUniformHash(builder: NodeBuilder): string;
+	onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+	generate(builder: NodeBuilder, output: string | null): string;
+}
+export default UniformNode;
+export declare const uniform: <TValue>(arg1: InputNode<TValue> | TValue, arg2?: Node | string) => import('../shadernode/ShaderNode.js').ShaderNodeObject<UniformNode<TValue>>;

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

@@ -0,0 +1,28 @@
+import { OperatorNodeOp } from '../math/OperatorNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+
+export default class VarNode extends Node {
+	node: Node;
+	name: string | null;
+
+	readonly isVarNode: true;
+
+	constructor(node: Node, name?: string | null);
+
+	op(op: OperatorNodeOp, ...params: Node[]): this;
+	assign(...params: Node[]): this;
+	add(...params: Node[]): this;
+	sub(...params: Node[]): this;
+	mul(...params: Node[]): this;
+	div(...params: Node[]): this;
+}
+
+export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		temp: typeof temp;
+		toVar: typeof temp;
+	}
+}

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

@@ -0,0 +1,21 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import NodeVarying from './NodeVarying.js';
+
+export default class VaryingNode extends Node {
+	node: Node;
+	name: string | null;
+
+	constructor(node: Node, name?: string | null);
+
+	setupVarying(builder: NodeBuilder): NodeVarying;
+}
+
+export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		varying: typeof varying;
+	}
+}