@nativescript/canvas-three 2.0.0-webgpu.33 → 2.0.0-webgpu.35

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

@@ -1,117 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

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

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

@@ -1,34 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

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

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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;
-	}
-}