@types/three 0.180.0 → 0.181.0

three/src/materials/nodes/NodeMaterial.d.ts

@@ -4,7 +4,6 @@ import MRTNode from "../../nodes/core/MRTNode.js";
 import Node from "../../nodes/core/Node.js";
 import NodeBuilder from "../../nodes/core/NodeBuilder.js";
 import LightsNode from "../../nodes/lighting/LightsNode.js";
-import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import { MapColorPropertiesToColorRepresentations, Material, MaterialParameters } from "../Material.js";
 import NodeMaterialObserver from "./manager/NodeMaterialObserver.js";
 
@@ -105,7 +104,7 @@ export interface NodeMaterialNodeProperties {
      * and `alphaMap` properties. This node property allows to overwrite the default
      * and define the opacity with a node instead.
      *
-     * If you don't want to overwrite the normals but modify the existing
+     * If you don't want to overwrite the opacity but modify the existing
      * value instead, use {@link materialOpacity}.
      *
      * @default null
@@ -385,7 +384,7 @@ declare class NodeMaterial extends Material {
      *
      * @return {Node<vec3>} The normal node.
      */
-    setupNormal(): ShaderNodeObject<Node>;
+    setupNormal(): Node;
     /**
      * Setups the environment node from the material.
      *

three/src/materials/nodes/VolumeNodeMaterial.d.ts

@@ -1,6 +1,5 @@
 import Node from "../../nodes/core/Node.js";
 import VolumetricLightingModel from "../../nodes/functions/VolumetricLightingModel.js";
-import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import { MapColorPropertiesToColorRepresentations, MaterialParameters, MaterialProperties } from "../Material.js";
 import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
@@ -23,7 +22,7 @@ export interface VolumeNodeMaterialNodeProperties extends NodeMaterialNodeProper
      *
      * @default null
      */
-    scatteringNode: (params: { positionRay: ShaderNodeObject<Node> }) => Node | null;
+    scatteringNode: (params: { positionRay: Node }) => Node | null;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/math/Vector3.d.ts

@@ -103,7 +103,7 @@ export class Vector3 {
     /**
      * Subtracts v from this vector.
      */
-    sub(a: Vector3Like): this;
+    sub(v: Vector3Like): this;
 
     subScalar(s: number): this;
 
@@ -208,7 +208,7 @@ export class Vector3 {
     /**
      * Sets this vector to cross product of itself and v.
      */
-    cross(a: Vector3Like): this;
+    cross(v: Vector3Like): this;
 
     /**
      * Sets this vector to cross product of a and b.

three/src/nodes/Nodes.d.ts

@@ -6,10 +6,10 @@ export { default as ArrayNode } from "./core/ArrayNode.js";
 export { default as AssignNode } from "./core/AssignNode.js";
 export { default as AttributeNode } from "./core/AttributeNode.js";
 export { default as BypassNode } from "./core/BypassNode.js";
-export { default as CacheNode } from "./core/CacheNode.js";
 export { default as ConstNode } from "./core/ConstNode.js";
 export { default as ContextNode } from "./core/ContextNode.js";
 export { default as IndexNode, IndexNodeScope } from "./core/IndexNode.js";
+export { default as IsolateNode } from "./core/IsolateNode.js";
 export {
     default as LightingModel,
     LightingModelDirectInput,

three/src/nodes/TSL.d.ts

@@ -5,9 +5,9 @@ export * from "./core/constants.js";
 export * from "./core/AssignNode.js";
 export * from "./core/AttributeNode.js";
 export * from "./core/BypassNode.js";
-export * from "./core/CacheNode.js";
 export * from "./core/ContextNode.js";
 export * from "./core/IndexNode.js";
+export * from "./core/IsolateNode.js";
 export * from "./core/MRTNode.js";
 export * from "./core/OutputStructNode.js";
 export * from "./core/ParameterNode.js";

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

@@ -1,9 +1,8 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const TBNViewMatrix: ShaderNodeObject<Node>;
+export const TBNViewMatrix: Node;
 
-export const parallaxDirection: ShaderNodeObject<Node>;
-export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: Node) => ShaderNodeObject<Node>;
+export const parallaxDirection: Node;
+export const parallaxUV: (uv: Node, scale: Node) => Node;
 
-export const bentNormalView: ShaderNodeObject<Node>;
+export const bentNormalView: Node;

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

@@ -1,14 +1,13 @@
 import { TypedArray } from "../../core/BufferAttribute.js";
 import { Struct } from "../core/StructNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageBufferNode from "./StorageBufferNode.js";
 
 export const attributeArray: (
     count: TypedArray | number,
     type?: string | Struct,
-) => ShaderNodeObject<StorageBufferNode>;
+) => StorageBufferNode;
 
 export const instancedArray: (
     count: TypedArray | number,
     type?: string | Struct,
-) => ShaderNodeObject<StorageBufferNode>;
+) => StorageBufferNode;

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

@@ -1,6 +1,5 @@
 import { BatchedMesh } from "../../objects/BatchedMesh.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class BatchNode extends Node {
     batchMesh: BatchedMesh;
@@ -10,4 +9,4 @@ export default class BatchNode extends Node {
     constructor(batchMesh: BatchedMesh);
 }
 
-export const batch: (batchMesh: BatchedMesh) => ShaderNodeObject<BatchNode>;
+export const batch: (batchMesh: BatchedMesh) => BatchNode;

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

@@ -1,7 +1,6 @@
 import MathNode from "../math/MathNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const bitangentGeometry: ShaderNodeObject<MathNode>;
-export const bitangentLocal: ShaderNodeObject<MathNode>;
-export const bitangentView: ShaderNodeObject<MathNode>;
-export const bitangentWorld: ShaderNodeObject<MathNode>;
+export const bitangentGeometry: MathNode;
+export const bitangentLocal: MathNode;
+export const bitangentView: MathNode;
+export const bitangentWorld: MathNode;

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

@@ -4,8 +4,6 @@ import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import InputNode from "../core/InputNode.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import BufferNode from "./BufferNode.js";
 /**
  * In earlier `three.js` versions it was only possible to define attribute data
  * on geometry level. With `BufferAttributeNode`, it is also possible to do this
@@ -121,7 +119,7 @@ export declare const bufferAttribute: (
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
+) => BufferAttributeNode;
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage.
  * Use this function if attribute data are updated per frame.
@@ -139,7 +137,7 @@ export declare const dynamicBufferAttribute: (
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
+) => BufferAttributeNode;
 /**
  * TSL function for creating a buffer attribute node but with enabled instancing
  *
@@ -156,7 +154,7 @@ export declare const instancedBufferAttribute: (
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
+) => BufferAttributeNode;
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage and enabled instancing
  *
@@ -173,9 +171,10 @@ export declare const instancedDynamicBufferAttribute: (
     type?: string | null,
     stride?: number,
     offset?: number,
-) => ShaderNodeObject<BufferAttributeNode>;
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toAttribute: <TValue>(bufferNode: BufferNode<TValue>) => ShaderNodeObject<BufferAttributeNode>;
+) => BufferAttributeNode;
+declare module "../Nodes.js" {
+    interface BufferNode<TValue> {
+        toAttribute: () => BufferAttributeNode;
+        toAttributeAssign: () => this;
     }
 }

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

@@ -1,5 +1,5 @@
 import UniformNode from "../core/UniformNode.js";
-import { NodeOrType, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeOrType } from "../tsl/TSLCore.js";
 
 export default class BufferNode<TValue> extends UniformNode<TValue> {
     isBufferNode: true;
@@ -14,4 +14,4 @@ export const buffer: <TValue>(
     value: unknown,
     nodeOrType: NodeOrType,
     count: number,
-) => ShaderNodeObject<BufferNode<TValue>>;
+) => BufferNode<TValue>;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class BuiltinNode extends Node {
     name: string;
@@ -11,4 +10,4 @@ declare class BuiltinNode extends Node {
 
 export default BuiltinNode;
 
-export const builtin: (name: string) => ShaderNodeObject<BuiltinNode>;
+export const builtin: (name: string) => BuiltinNode;

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

@@ -3,15 +3,14 @@ import { Matrix4 } from "../../math/Matrix4.js";
 import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const cameraIndex: ShaderNodeObject<UniformNode<number>>;
-export const cameraNear: ShaderNodeObject<UniformNode<number>>;
-export const cameraFar: ShaderNodeObject<UniformNode<number>>;
-export const cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraViewMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraWorldMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-export const cameraNormalMatrix: ShaderNodeObject<UniformNode<Matrix3>>;
-export const cameraPosition: ShaderNodeObject<UniformNode<Vector3>>;
-export const cameraViewport: ShaderNodeObject<UniformNode<Vector4>>;
+export const cameraIndex: UniformNode<number>;
+export const cameraNear: UniformNode<number>;
+export const cameraFar: UniformNode<number>;
+export const cameraProjectionMatrix: UniformNode<Matrix4>;
+export const cameraProjectionMatrixInverse: UniformNode<Matrix4>;
+export const cameraViewMatrix: UniformNode<Matrix4>;
+export const cameraWorldMatrix: UniformNode<Matrix4>;
+export const cameraNormalMatrix: UniformNode<Matrix3>;
+export const cameraPosition: UniformNode<Vector3>;
+export const cameraViewport: UniformNode<Vector4>;

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

@@ -1,7 +1,4 @@
-import { Plane } from "../../math/Plane.js";
 import Node from "../core/Node.js";
-import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof ClippingNode.DEFAULT;
 
@@ -17,6 +14,6 @@ export default class ClippingNode extends Node {
     static HARDWARE: "hardware";
 }
 
-export const clipping: () => ShaderNodeObject<ClippingNode>;
-export const clippingAlpha: () => ShaderNodeObject<ClippingNode>;
-export const hardwareClipping: () => ShaderNodeObject<ClippingNode>;
+export const clipping: () => ClippingNode;
+export const clippingAlpha: () => ClippingNode;
+export const hardwareClipping: () => ClippingNode;

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

@@ -1,18 +1,17 @@
 import { CubeTexture } from "../../textures/CubeTexture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import TextureNode from "./TextureNode.js";
 
 declare class CubeTextureNode extends TextureNode {
     isCubeTextureNode: boolean;
-    uvNode: ShaderNodeObject<Node> | null;
-    levelNode: ShaderNodeObject<Node> | null;
+    uvNode: Node | null;
+    levelNode: Node | null;
 
     constructor(
         value: CubeTexture,
-        uvNode?: ShaderNodeObject<Node> | null,
-        levelNode?: ShaderNodeObject<Node> | null,
-        biasNode?: ShaderNodeObject<Node> | null,
+        uvNode?: Node | null,
+        levelNode?: Node | null,
+        biasNode?: Node | null,
     );
 
     getDefaultUV(): Node;
@@ -25,15 +24,15 @@ export const cubeTextureBase: (
     uvNode?: Node,
     levelNode?: Node,
     biasNode?: Node,
-) => ShaderNodeObject<CubeTextureNode>;
+) => CubeTextureNode;
 
 export const cubeTexture: (
     value?: CubeTexture,
     uvNode?: Node | null,
     levelNode?: Node | null,
     biasNode?: Node | null,
-) => ShaderNodeObject<CubeTextureNode>;
+) => CubeTextureNode;
 
 export const uniformCubeTexture: (
     value?: CubeTexture,
-) => ShaderNodeObject<CubeTextureNode>;
+) => CubeTextureNode;

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

@@ -1,6 +1,5 @@
 import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class InstanceNode extends Node {
     count: number;
@@ -21,4 +20,4 @@ export const instance: (
     count: number,
     instanceMatrix: InstancedBufferAttribute,
     instanceColor?: InstancedBufferAttribute | null,
-) => ShaderNodeObject<InstanceNode>;
+) => InstanceNode;

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

@@ -1,5 +1,4 @@
 import { InstancedMesh } from "../../objects/InstancedMesh.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import InstanceNode from "./InstanceNode.js";
 
 declare class InstancedMeshNode extends InstanceNode {
@@ -8,4 +7,4 @@ declare class InstancedMeshNode extends InstanceNode {
 
 export default InstancedMeshNode;
 
-export const instancedMesh: (instancedMesh: InstancedMesh) => ShaderNodeObject<InstancedMeshNode>;
+export const instancedMesh: (instancedMesh: InstancedMesh) => InstancedMeshNode;

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

@@ -1,15 +1,14 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export function lightShadowMatrix(light: Light): ShaderNodeObject<Node>;
+export function lightShadowMatrix(light: Light): Node;
 
-export function lightProjectionUV(light: Light, position?: Node): ShaderNodeObject<Node>;
+export function lightProjectionUV(light: Light, position?: Node): Node;
 
-export function lightPosition(light: Light): ShaderNodeObject<Node>;
+export function lightPosition(light: Light): Node;
 
-export function lightTargetPosition(light: Light): ShaderNodeObject<Node>;
+export function lightTargetPosition(light: Light): Node;
 
-export function lightViewPosition(light: Light): ShaderNodeObject<Node>;
+export function lightViewPosition(light: Light): Node;
 
-export const lightTargetDirection: (light: Light) => ShaderNodeObject<Node>;
+export const lightTargetDirection: (light: Light) => Node;

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

@@ -1,7 +1,6 @@
 import { Vector2 } from "../../math/Vector2.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type MaterialNodeScope =
     | typeof MaterialNode.ALPHA_TEST
@@ -87,43 +86,43 @@ export default class MaterialNode extends Node {
     constructor(scope?: MaterialNodeScope);
 }
 
-export const materialAlphaTest: ShaderNodeObject<MaterialNode>;
-export const materialColor: ShaderNodeObject<MaterialNode>;
-export const materialShininess: ShaderNodeObject<MaterialNode>;
-export const materialEmissive: ShaderNodeObject<MaterialNode>;
-export const materialOpacity: ShaderNodeObject<MaterialNode>;
-export const materialSpecular: ShaderNodeObject<MaterialNode>;
+export const materialAlphaTest: MaterialNode;
+export const materialColor: MaterialNode;
+export const materialShininess: MaterialNode;
+export const materialEmissive: MaterialNode;
+export const materialOpacity: MaterialNode;
+export const materialSpecular: MaterialNode;
 
-export const materialSpecularIntensity: ShaderNodeObject<MaterialNode>;
-export const materialSpecularColor: ShaderNodeObject<MaterialNode>;
+export const materialSpecularIntensity: MaterialNode;
+export const materialSpecularColor: MaterialNode;
 
-export const materialSpecularStrength: ShaderNodeObject<MaterialNode>;
-export const materialReflectivity: ShaderNodeObject<MaterialNode>;
-export const materialRoughness: ShaderNodeObject<MaterialNode>;
-export const materialMetalness: ShaderNodeObject<MaterialNode>;
-export const materialNormal: ShaderNodeObject<Node>;
-export const materialClearcoat: ShaderNodeObject<MaterialNode>;
-export const materialClearcoatRoughness: ShaderNodeObject<MaterialNode>;
-export const materialClearcoatNormal: ShaderNodeObject<Node>;
-export const materialRotation: ShaderNodeObject<MaterialNode>;
-export const materialSheen: ShaderNodeObject<MaterialNode>;
-export const materialSheenRoughness: ShaderNodeObject<MaterialNode>;
-export const materialAnisotropy: ShaderNodeObject<MaterialNode>;
-export const materialIridescence: ShaderNodeObject<MaterialNode>;
-export const materialIridescenceIOR: ShaderNodeObject<MaterialNode>;
-export const materialIridescenceThickness: ShaderNodeObject<MaterialNode>;
-export const materialTransmission: ShaderNodeObject<MaterialNode>;
-export const materialThickness: ShaderNodeObject<MaterialNode>;
-export const materialIOR: ShaderNodeObject<MaterialNode>;
-export const materialAttenuationDistance: ShaderNodeObject<MaterialNode>;
-export const materialAttenuationColor: ShaderNodeObject<MaterialNode>;
-export const materialLineScale: ShaderNodeObject<MaterialNode>;
-export const materialLineDashSize: ShaderNodeObject<MaterialNode>;
-export const materialLineGapSize: ShaderNodeObject<MaterialNode>;
-export const materialLineWidth: ShaderNodeObject<MaterialNode>;
-export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
-export const materialPointSize: ShaderNodeObject<MaterialNode>;
-export const materialDispersion: ShaderNodeObject<MaterialNode>;
-export const materialLightMap: ShaderNodeObject<MaterialNode>;
-export const materialAO: ShaderNodeObject<MaterialNode>;
-export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;
+export const materialSpecularStrength: MaterialNode;
+export const materialReflectivity: MaterialNode;
+export const materialRoughness: MaterialNode;
+export const materialMetalness: MaterialNode;
+export const materialNormal: Node;
+export const materialClearcoat: MaterialNode;
+export const materialClearcoatRoughness: MaterialNode;
+export const materialClearcoatNormal: Node;
+export const materialRotation: MaterialNode;
+export const materialSheen: MaterialNode;
+export const materialSheenRoughness: MaterialNode;
+export const materialAnisotropy: MaterialNode;
+export const materialIridescence: MaterialNode;
+export const materialIridescenceIOR: MaterialNode;
+export const materialIridescenceThickness: MaterialNode;
+export const materialTransmission: MaterialNode;
+export const materialThickness: MaterialNode;
+export const materialIOR: MaterialNode;
+export const materialAttenuationDistance: MaterialNode;
+export const materialAttenuationColor: MaterialNode;
+export const materialLineScale: MaterialNode;
+export const materialLineDashSize: MaterialNode;
+export const materialLineGapSize: MaterialNode;
+export const materialLineWidth: MaterialNode;
+export const materialLineDashOffset: MaterialNode;
+export const materialPointSize: MaterialNode;
+export const materialDispersion: MaterialNode;
+export const materialLightMap: MaterialNode;
+export const materialAO: MaterialNode;
+export const materialAnisotropyVector: UniformNode<Vector2>;

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

@@ -1,9 +1,8 @@
 import { Matrix4 } from "../../math/Matrix4.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const materialRefractionRatio: ShaderNodeObject<UniformNode<number>>;
+export const materialRefractionRatio: UniformNode<number>;
 
-export const materialEnvIntensity: ShaderNodeObject<UniformNode<number>>;
+export const materialEnvIntensity: UniformNode<number>;
 
-export const materialEnvRotation: ShaderNodeObject<UniformNode<Matrix4>>;
+export const materialEnvRotation: UniformNode<Matrix4>;

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

@@ -1,5 +1,5 @@
 import { Material } from "../../materials/Material.js";
-import { NodeOrType, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeOrType } from "../tsl/TSLCore.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
@@ -12,4 +12,4 @@ export const materialReference: (
     name: string,
     nodeOrType: NodeOrType,
     material?: Material | null,
-) => ShaderNodeObject<MaterialReferenceNode>;
+) => MaterialReferenceNode;

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

@@ -1,7 +1,6 @@
 import { Matrix4 } from "../../math/Matrix4.js";
 import Node from "../core/Node.js";
 import { UniformNode } from "../Nodes.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Object3DNode from "./Object3DNode.js";
 
 /**
@@ -11,23 +10,23 @@ export default class ModelNode extends Object3DNode {
     constructor(scope: string);
 }
 
-export const modelDirection: ShaderNodeObject<ModelNode>;
-export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
-export const modelPosition: ShaderNodeObject<ModelNode>;
-export const modelScale: ShaderNodeObject<ModelNode>;
-export const modelViewPosition: ShaderNodeObject<ModelNode>;
-export const modelRadius: ShaderNodeObject<ModelNode>;
-export const modelNormalMatrix: ShaderNodeObject<Node>;
-export const modelWorldMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+export const modelDirection: ModelNode;
+export const modelWorldMatrix: ModelNode;
+export const modelPosition: ModelNode;
+export const modelScale: ModelNode;
+export const modelViewPosition: ModelNode;
+export const modelRadius: ModelNode;
+export const modelNormalMatrix: Node;
+export const modelWorldMatrixInverse: UniformNode<Matrix4>;
 
-export const modelViewMatrix: ShaderNodeObject<ModelNode>;
+export const modelViewMatrix: ModelNode;
 
 // GPU Precision
 
-export const mediumpModelViewMatrix: ShaderNodeObject<Node>;
+export const mediumpModelViewMatrix: Node;
 
 // CPU Precision
 
-export const highpModelViewMatrix: ShaderNodeObject<Node>;
+export const highpModelViewMatrix: Node;
 
-export const highpModelNormalViewMatrix: ShaderNodeObject<Node>;
+export const highpModelNormalViewMatrix: Node;

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

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const modelViewProjection: ShaderNodeObject<Node>;
+export const modelViewProjection: Node;

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

@@ -1,7 +1,6 @@
 import { Mesh } from "../../objects/Mesh.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class MorphNode extends Node {
     mesh: Mesh;
@@ -12,4 +11,4 @@ declare class MorphNode extends Node {
 
 export default MorphNode;
 
-export const morphReference: (mesh: Mesh) => ShaderNodeObject<MorphNode>;
+export const morphReference: (mesh: Mesh) => MorphNode;

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

@@ -1,39 +1,38 @@
 import AttributeNode from "../core/AttributeNode.js";
 import Node from "../core/Node.js";
 import VarNode from "../core/VarNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const normalGeometry: ShaderNodeObject<AttributeNode>;
+export const normalGeometry: AttributeNode;
 
-export const normalLocal: ShaderNodeObject<VarNode>;
+export const normalLocal: VarNode;
 
-export const normalFlat: ShaderNodeObject<VarNode>;
+export const normalFlat: VarNode;
 
-export const normalViewGeometry: ShaderNodeObject<VarNode>;
+export const normalViewGeometry: VarNode;
 
-export const normalWorldGeometry: ShaderNodeObject<VarNode>;
+export const normalWorldGeometry: VarNode;
 
-export const normalView: ShaderNodeObject<VarNode>;
+export const normalView: VarNode;
 
-export const normalWorld: ShaderNodeObject<VarNode>;
+export const normalWorld: VarNode;
 
-export const clearcoatNormalView: ShaderNodeObject<VarNode>;
+export const clearcoatNormalView: VarNode;
 
-export const transformNormal: (normal: Node, matrix?: Node) => ShaderNodeObject<Node>;
+export const transformNormal: (normal: Node, matrix?: Node) => Node;
 
-export const transformNormalToView: (normal: Node) => ShaderNodeObject<Node>;
+export const transformNormalToView: (normal: Node) => Node;
 
 /**
  * @deprecated since r178. Use `normalView` instead.
  */
-export const transformedNormalView: ShaderNodeObject<VarNode>;
+export const transformedNormalView: VarNode;
 
 /**
  * @deprecated since r178. Use `normalWorld` instead.
  */
-export const transformedNormalWorld: ShaderNodeObject<VarNode>;
+export const transformedNormalWorld: VarNode;
 
 /**
  * @deprecated since r178. Use `clearcoatNormalView` instead.
  */
-export const transformedClearcoatNormalView: ShaderNodeObject<VarNode>;
+export const transformedClearcoatNormalView: VarNode;

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

@@ -1,6 +1,5 @@
 import { Object3D } from "../../core/Object3D.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class Object3DNode extends Node {
     scope: string;
@@ -16,9 +15,9 @@ export default class Object3DNode extends Node {
     static RADIUS: "radius";
 }
 
-export const objectDirection: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectWorldMatrix: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectPosition: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectScale: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectViewPosition: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
-export const objectRadius: (object3d: Object3D | null) => ShaderNodeObject<Object3DNode>;
+export const objectDirection: (object3d: Object3D | null) => Object3DNode;
+export const objectWorldMatrix: (object3d: Object3D | null) => Object3DNode;
+export const objectPosition: (object3d: Object3D | null) => Object3DNode;
+export const objectScale: (object3d: Object3D | null) => Object3DNode;
+export const objectViewPosition: (object3d: Object3D | null) => Object3DNode;
+export const objectRadius: (object3d: Object3D | null) => Object3DNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class PointUVNode extends Node {
     isPointUVNode: true;
@@ -7,4 +6,4 @@ export default class PointUVNode extends Node {
     constructor();
 }
 
-export const pointUV: ShaderNodeObject<PointUVNode>;
+export const pointUV: PointUVNode;