@types/three 0.180.0 → 0.181.0

three/src/nodes/accessors/Position.d.ts

@@ -1,10 +1,9 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const positionGeometry: ShaderNodeObject<Node>;
-export const positionLocal: ShaderNodeObject<Node>;
-export const positionPrevious: ShaderNodeObject<Node>;
-export const positionWorld: ShaderNodeObject<Node>;
-export const positionWorldDirection: ShaderNodeObject<Node>;
-export const positionView: ShaderNodeObject<Node>;
-export const positionViewDirection: ShaderNodeObject<Node>;
+export const positionGeometry: Node;
+export const positionLocal: Node;
+export const positionPrevious: Node;
+export const positionWorld: Node;
+export const positionWorldDirection: Node;
+export const positionView: Node;
+export const positionViewDirection: Node;

three/src/nodes/accessors/ReferenceBaseNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ReferenceBaseNode<T> extends Node {
     property: string;
@@ -18,10 +17,10 @@ declare class ReferenceBaseNode<T> extends Node {
 
 export default ReferenceBaseNode;
 
-export const reference: <T>(name: string, type: string, object: T) => ShaderNodeObject<ReferenceBaseNode<T>>;
+export const reference: <T>(name: string, type: string, object: T) => ReferenceBaseNode<T>;
 export const referenceBuffer: <T>(
     name: string,
     type: string,
     count: number,
     object: T,
-) => ShaderNodeObject<ReferenceBaseNode<T>>;
+) => ReferenceBaseNode<T>;

three/src/nodes/accessors/ReferenceNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ReferenceNode<T> extends Node {
     property: string;
@@ -20,10 +19,10 @@ declare class ReferenceNode<T> extends Node {
 
 export default ReferenceNode;
 
-export const reference: <T>(name: string, type: string, object: T) => ShaderNodeObject<ReferenceNode<T>>;
+export const reference: <T>(name: string, type: string, object: T) => ReferenceNode<T>;
 export const referenceBuffer: <T>(
     name: string,
     type: string,
     count: number,
     object: T,
-) => ShaderNodeObject<ReferenceNode<T>>;
+) => ReferenceNode<T>;

three/src/nodes/accessors/ReflectVector.d.ts

@@ -1,9 +1,8 @@
 import Node from "../core/Node.js";
 import VarNode from "../core/VarNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const reflectView: ShaderNodeObject<Node>;
-export const refractView: ShaderNodeObject<Node>;
+export const reflectView: Node;
+export const refractView: Node;
 
-export const reflectVector: ShaderNodeObject<VarNode>;
-export const refractVector: ShaderNodeObject<VarNode>;
+export const reflectVector: VarNode;
+export const refractVector: VarNode;

three/src/nodes/accessors/RendererReferenceNode.d.ts

@@ -1,5 +1,4 @@
 import Renderer from "../../renderers/common/Renderer.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export default class RendererReferenceNode extends ReferenceNode<Renderer> {
@@ -12,4 +11,4 @@ export const rendererReference: (
     name: string,
     type: string,
     renderer?: Renderer | null,
-) => ShaderNodeObject<RendererReferenceNode>;
+) => RendererReferenceNode;

three/src/nodes/accessors/SceneNode.d.ts

@@ -1,6 +1,5 @@
 import { Scene } from "../../scenes/Scene.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type SceneNodeScope = typeof SceneNode.BACKGROUND_BLURRINESS | typeof SceneNode.BACKGROUND_INTENSITY;
 
@@ -17,6 +16,6 @@ declare class SceneNode extends Node {
 
 export default SceneNode;
 
-export const backgroundBlurriness: ShaderNodeObject<SceneNode>;
-export const backgroundIntensity: ShaderNodeObject<SceneNode>;
-export const backgroundRotation: ShaderNodeObject<SceneNode>;
+export const backgroundBlurriness: SceneNode;
+export const backgroundIntensity: SceneNode;
+export const backgroundRotation: SceneNode;

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

@@ -1,7 +1,6 @@
 import { SkinnedMesh } from "../../objects/SkinnedMesh.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class SkinningNode extends Node {
     skinnedMesh: SkinnedMesh;
@@ -18,14 +17,14 @@ export default class SkinningNode extends Node {
 
     constructor(skinnedMesh: SkinnedMesh);
 
-    getSkinnedPosition(boneMatrices?: Node, position?: Node): ShaderNodeObject<Node>;
+    getSkinnedPosition(boneMatrices?: Node, position?: Node): Node;
 
-    getSkinnedNormal(boneMatrices?: Node, normal?: Node): ShaderNodeObject<Node>;
+    getSkinnedNormal(boneMatrices?: Node, normal?: Node): Node;
 
-    getPreviousSkinnedPosition(builder: NodeBuilder): ShaderNodeObject<Node>;
+    getPreviousSkinnedPosition(builder: NodeBuilder): Node;
 
     needsPreviousBoneMatrices(builder: NodeBuilder): boolean;
 }
 
-export const skinning: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;
-export const computeSkinning: (skinnedMesh: SkinnedMesh, toPosition?: Node | null) => ShaderNodeObject<SkinningNode>;
+export const skinning: (skinnedMesh: SkinnedMesh) => SkinningNode;
+export const computeSkinning: (skinnedMesh: SkinnedMesh, toPosition?: Node | null) => SkinningNode;

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

@@ -1,10 +1,10 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import { NodeAccess } from "../core/constants.js";
 import Node from "../core/Node.js";
 import { Struct } from "../core/StructNode.js";
 import StructTypeNode from "../core/StructTypeNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -25,7 +25,7 @@ export default class StorageBufferNode extends BufferNode<StorageBufferAttribute
         bufferCount?: number,
     );
 
-    element(indexNode: Node | number): ShaderNodeObject<StorageArrayElementNode>;
+    element: (indexNode: Node | number) => StorageArrayElementNode;
 
     setPBO(value: boolean): this;
 
@@ -41,10 +41,10 @@ export default class StorageBufferNode extends BufferNode<StorageBufferAttribute
 }
 
 export const storage: (
-    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+    value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
     type?: string | Struct | null,
     count?: number,
-) => ShaderNodeObject<StorageBufferNode>;
+) => StorageBufferNode;
 
 /**
  * @deprecated
@@ -53,4 +53,4 @@ export const storageObject: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
     type?: string | Struct | null,
     count?: number,
-) => ShaderNodeObject<StorageBufferNode>;
+) => StorageBufferNode;

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

@@ -2,24 +2,27 @@ import { Texture } from "../../textures/Texture.js";
 import { NodeAccess } from "../core/constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 export default class StorageTextureNode extends TextureNode {
     storeNode: Node | null;
 
+    mipLevel: number;
+
     readonly isStorageTextureNode: true;
 
     access: NodeAccess;
 
     constructor(
         value: Texture,
-        uvNode?: ShaderNodeObject<Node> | null,
+        uvNode?: Node | null,
         storeNode?: Node | null,
     );
 
     setAccess(value: NodeAccess): this;
 
+    setMipLevel(level: number): this;
+
     toReadWrite(): this;
 
     toReadOnly(): this;
@@ -33,10 +36,10 @@ export const storageTexture: (
     value: Texture,
     uvNode?: Node | null,
     storeNode?: Node,
-) => ShaderNodeObject<StorageTextureNode>;
+) => StorageTextureNode;
 
 export const textureStore: (
     value: Texture,
     uvNode?: Node | null,
     storeNode?: Node,
-) => ShaderNodeObject<StorageTextureNode>;
+) => StorageTextureNode;

three/src/nodes/accessors/Tangent.d.ts

@@ -1,10 +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 "../tsl/TSLCore.js";
 
-export const tangentGeometry: ShaderNodeObject<AttributeNode>;
-export const tangentLocal: ShaderNodeObject<VaryingNode>;
-export const tangentView: ShaderNodeObject<MathNode>;
-export const tangentWorld: ShaderNodeObject<MathNode>;
+export const tangentGeometry: AttributeNode;
+export const tangentLocal: VaryingNode;
+export const tangentView: MathNode;
+export const tangentWorld: MathNode;

three/src/nodes/accessors/TangentUtils.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 /**
  * Tangent vector in view space, computed dynamically from geometry and UV derivatives.
@@ -9,7 +8,7 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
  *
  * @tsl
  */
-export const tangentViewFrame: ShaderNodeObject<Node>;
+export const tangentViewFrame: Node;
 
 /**
  * Bitangent vector in view space, computed dynamically from geometry and UV derivatives.
@@ -19,4 +18,4 @@ export const tangentViewFrame: ShaderNodeObject<Node>;
  *
  * @tsl
  */
-export const bitangentViewFrame: ShaderNodeObject<Node>;
+export const bitangentViewFrame: Node;

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

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

three/src/nodes/accessors/TextureBicubic.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const textureBicubicLevel: (textureNode: Node, lodNode: Node) => ShaderNodeObject<Node>;
+export const textureBicubicLevel: (textureNode: Node, lodNode: Node) => Node;
 
-export const textureBicubic: (textureNode: Node, strength: Node) => ShaderNodeObject<Node>;
+export const textureBicubic: (textureNode: Node, strength: Node) => Node;

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

@@ -1,14 +1,13 @@
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class TextureNode extends UniformNode<Texture> {
     readonly isTextureNode: true;
 
-    uvNode: ShaderNodeObject<Node> | null;
-    levelNode: ShaderNodeObject<Node> | null;
-    biasNode: ShaderNodeObject<Node> | null;
+    uvNode: Node | null;
+    levelNode: Node | null;
+    biasNode: Node | null;
     compareNode: Node | null;
     depthNode: Node | null;
     gradNode: Node | null;
@@ -20,9 +19,9 @@ export default class TextureNode extends UniformNode<Texture> {
 
     constructor(
         value?: Texture,
-        uvNode?: ShaderNodeObject<Node> | null,
-        levelNode?: ShaderNodeObject<Node> | null,
-        biasNode?: ShaderNodeObject<Node> | null,
+        uvNode?: Node | null,
+        levelNode?: Node | null,
+        biasNode?: Node | null,
     );
 
     getDefaultUV(): Node;
@@ -34,49 +33,55 @@ export default class TextureNode extends UniformNode<Texture> {
     /**
      * @deprecated
      */
-    uv(uvNode: Node): ShaderNodeObject<Node>;
+    uv(uvNode: Node): Node;
 
-    sample(uvNode: Node): ShaderNodeObject<Node>;
+    sample(uvNode: Node): Node;
 
-    load(uvNode: Node): ShaderNodeObject<Node>;
+    load(uvNode: Node): Node;
 
-    blur(amountNode: Node): ShaderNodeObject<Node>;
+    blur(amountNode: Node): Node;
 
-    level(levelNode: Node): ShaderNodeObject<Node>;
+    level(levelNode: Node): Node;
 
-    size(levelNode: Node): ShaderNodeObject<Node>;
+    size(levelNode: Node): Node;
 
-    bias(biasNode: Node): ShaderNodeObject<Node>;
+    bias(biasNode: Node): Node;
 
     getBase(): TextureNode;
 
-    compare(compareNode: Node): ShaderNodeObject<Node>;
+    compare(compareNode: Node): Node;
 
-    grad(gradeNodeX: Node, gradeNodeY: Node): ShaderNodeObject<Node>;
+    grad(gradeNodeX: Node, gradeNodeY: Node): Node;
 
-    depth(depthNode: Node): ShaderNodeObject<Node>;
+    depth(depthNode: Node): Node;
 
     clone(): this;
 }
 
 export const texture: (
-    value?: Texture,
+    value?: Texture | TextureNode,
     uvNode?: Node | null,
     levelNode?: Node | number | null,
     biasNode?: Node | null,
-) => ShaderNodeObject<TextureNode>;
+) => TextureNode;
 
 export const uniformTexture: (
     value?: Texture,
-) => ShaderNodeObject<TextureNode>;
+) => TextureNode;
 
 export const textureLoad: (
-    value?: Texture,
+    value?: Texture | TextureNode,
     uvNode?: Node,
     levelNode?: Node | number,
     biasNode?: Node,
-) => ShaderNodeObject<TextureNode>;
+) => TextureNode;
+
+export const textureLevel: (
+    value: Texture | TextureNode,
+    uv: Node,
+    level: Node,
+) => TextureNode;
 
-export const sampler: (value: Texture | TextureNode) => ShaderNodeObject<Node>;
+export const sampler: (value: Texture | TextureNode) => Node;
 
-export const samplerComparison: (value: Texture | TextureNode) => ShaderNodeObject<Node>;
+export const samplerComparison: (value: Texture | TextureNode) => Node;

three/src/nodes/accessors/TextureSizeNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class TextureSizeNode extends Node {
     readonly isTextureSizeNode: true;
@@ -15,4 +14,4 @@ export default TextureSizeNode;
 export const textureSize: (
     textureNode: Node,
     levelNode?: Node | null,
-) => ShaderNodeObject<TextureSizeNode>;
+) => TextureSizeNode;

three/src/nodes/accessors/UV.d.ts

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

three/src/nodes/accessors/UniformArrayNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "../utils/ArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -18,9 +17,9 @@ declare class UniformArrayNode extends BufferNode<unknown[]> {
 
     getPaddedType(): string;
 
-    element(indexNode: Node): ShaderNodeObject<UniformArrayElementNode>;
+    element: (indexNode: Node) => UniformArrayElementNode;
 }
 
 export default UniformArrayNode;
 
-export const uniformArray: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformArrayNode>;
+export const uniformArray: (values: unknown[], nodeType?: string | null) => UniformArrayNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export type NodeUserData = Record<string, any>;
@@ -12,4 +11,4 @@ export const userData: (
     name: string,
     inputType: string,
     userData?: NodeUserData,
-) => ShaderNodeObject<UserDataNode>;
+) => UserDataNode;

three/src/nodes/accessors/VelocityNode.d.ts

@@ -1,7 +1,6 @@
 import { Matrix4 } from "../../math/Matrix4.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class VelocityNode extends TempNode {
     projectionMatrix: Matrix4 | null;
@@ -17,4 +16,4 @@ declare class VelocityNode extends TempNode {
 
 export default VelocityNode;
 
-export const velocity: ShaderNodeObject<VelocityNode>;
+export const velocity: VelocityNode;

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

@@ -1,5 +1,4 @@
 import AttributeNode from "../core/AttributeNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class VertexColorNode extends AttributeNode {
     readonly isVertexColorNode: true;
@@ -9,4 +8,4 @@ export default class VertexColorNode extends AttributeNode {
     constructor(index: number);
 }
 
-export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;
+export const vertexColor: (index?: number) => VertexColorNode;

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;
@@ -17,7 +16,7 @@ export default class CodeNode extends Node {
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
 
-export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => ShaderNodeObject<CodeNode>;
-export const js: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
-export const wgsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
-export const glsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
+export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => CodeNode;
+export const js: (src: string, includes?: CodeNodeInclude[]) => CodeNode;
+export const wgsl: (src: string, includes?: CodeNodeInclude[]) => CodeNode;
+export const glsl: (src: string, includes?: CodeNodeInclude[]) => CodeNode;

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

@@ -1,5 +1,4 @@
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ExpressionNode extends TempNode {
     snipped: string;
@@ -7,4 +6,4 @@ export default class ExpressionNode extends TempNode {
     constructor(snipped?: string, nodeType?: string);
 }
 
-export const expression: (snipped: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;
+export const expression: (snipped: string, nodeType?: string) => ExpressionNode;

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ProxiedObject, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ProxiedObject } from "../tsl/TSLCore.js";
 import FunctionNode, { FunctionNodeArguments } from "./FunctionNode.js";
 
 export default class FunctionCallNode<P extends Array<Node | number> | { [name: string]: Node | number }>
@@ -18,10 +18,11 @@ export default class FunctionCallNode<P extends Array<Node | number> | { [name:
 export const call: <P extends FunctionNodeArguments>(
     functionNode?: FunctionNode<P>,
     parameters?: ProxiedObject<P>,
-) => ShaderNodeObject<FunctionCallNode<P>>;
+) => FunctionCallNode<P>;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        call: typeof call;
+declare module "../Nodes.js" {
+    interface FunctionNode<P extends FunctionNodeArguments> {
+        call: (parameters?: ProxiedObject<P>) => FunctionCallNode<P>;
+        callAssign: (parameters?: ProxiedObject<P>) => this;
     }
 }

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

@@ -2,9 +2,8 @@ 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 "../tsl/TSLCore.js";
+import { ProxiedObject, ProxiedTuple } from "../tsl/TSLCore.js";
 import CodeNode, { CodeNodeInclude } from "./CodeNode.js";
-import FunctionCallNode from "./FunctionCallNode.js";
 
 export type FunctionNodeArguments = Array<Node | number> | { [name: string]: Node | number };
 
@@ -13,7 +12,6 @@ export default class FunctionNode<P extends Array<Node | number> | { [name: stri
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];
     getNodeFunction(builder: NodeBuilder): NodeFunction;
-    call(parameters: P): FunctionCallNode<P>;
 }
 
 type FnParameters<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
@@ -24,15 +22,15 @@ export const nativeFn: <P extends FunctionNodeArguments>(
     includes?: CodeNodeInclude[],
     language?: string,
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => Node;
 
 export const glslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => Node;
 export const wgslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => Node;

three/src/nodes/code/ScriptableNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class Resources extends Map<string, unknown> {
     get<TArgs extends unknown[]>(key: string, callback?: ((...args: TArgs) => void) | null, ...params: TArgs): unknown;
@@ -19,4 +18,4 @@ export default ScriptableNode;
 export const scriptable: (
     codeNode: Node,
     parameters?: Record<string, unknown>,
-) => ShaderNodeObject<ScriptableNode>;
+) => ScriptableNode;

three/src/nodes/code/ScriptableValueNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ScriptableValueNode extends Node {
     constructor(value: unknown);
@@ -7,4 +6,4 @@ declare class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-export const scriptableValue: (value: unknown) => ShaderNodeObject<ScriptableValueNode>;
+export const scriptableValue: (value: unknown) => ScriptableValueNode;

three/src/nodes/core/ArrayNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import TempNode from "./TempNode.js";
 
@@ -13,14 +12,15 @@ declare class ArrayNode extends TempNode {
 export default ArrayNode;
 
 interface ArrayFunction {
-    (values: Node[]): ShaderNodeObject<ArrayNode>;
-    (nodeType: string, count: number): ShaderNodeObject<ArrayNode>;
+    (values: Node[]): ArrayNode;
+    (nodeType: string, count: number): ArrayNode;
 }
 
 export const array: ArrayFunction;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toArray: typeof array;
+declare module "../Nodes.js" {
+    interface Node {
+        toArray: (count: number) => ArrayNode;
+        toArrayAssign: (count: number) => this;
     }
 }

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import TempNode from "./TempNode.js";
@@ -13,10 +12,4 @@ declare class AssignNode extends TempNode {
 
 export default AssignNode;
 
-export const assign: (targetNode: Node, sourceNode: Node | number) => ShaderNodeObject<AssignNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        assign: typeof assign;
-    }
-}
+export const assign: (targetNode: Node, sourceNode: Node | number) => AssignNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
@@ -13,4 +12,4 @@ export default class AttributeNode extends Node {
 export const attribute: (
     name: string,
     nodeType?: string | null,
-) => ShaderNodeObject<AttributeNode>;
+) => AttributeNode;