@types/three 0.179.0 → 0.181.0

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;

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;