@types/three 0.180.0 → 0.181.0

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class BypassNode extends Node {
@@ -9,10 +8,11 @@ export default class BypassNode extends Node {
     constructor(returnNode: Node, callNode: Node);
 }
 
-export const bypass: (returnNode: Node, callNode: Node) => ShaderNodeObject<BypassNode>;
+export const bypass: (returnNode: Node, callNode: Node) => BypassNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        bypass: typeof bypass;
+declare module "../Nodes.js" {
+    interface Node {
+        bypass: (callNode: Node) => BypassNode;
+        bypassAssign: (callNode: Node) => this;
     }
 }

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import { NodeBuilderContext } from "./NodeBuilder.js";
 
@@ -13,22 +12,35 @@ declare class ContextNode extends Node {
 
 export default ContextNode;
 
-export const context: (node: Node, context?: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
+export const context: (node: Node, context?: NodeBuilderContext) => ContextNode;
 
-export const uniformFlow: (node: Node) => ShaderNodeObject<ContextNode>;
+export const uniformFlow: (node: Node) => ContextNode;
 
-export const setName: (node: Node, label: string) => ShaderNodeObject<ContextNode>;
+export const setName: (node: Node, label: string) => Node;
 
 /**
  * @deprecated "label()" has been deprecated. Use "setName()" instead.
  */
-export function label(node: Node, label: string): ShaderNodeObject<ContextNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        context: typeof context;
-        label: typeof label;
-        uniformFlow: typeof uniformFlow;
-        setName: typeof setName;
+export function label(node: Node, label: string): Node;
+
+declare module "../Nodes.js" {
+    interface Node {
+        context: (context?: NodeBuilderContext) => ContextNode;
+        contextAssign: (context?: NodeBuilderContext) => this;
+
+        /**
+         * @deprecated "label()" has been deprecated. Use "setName()" instead.
+         */
+        label: (label: string) => Node;
+        /**
+         * @deprecated "label()" has been deprecated. Use "setName()" instead.
+         */
+        labelAssign: (label: string) => this;
+
+        uniformFlow: () => ContextNode;
+        uniformFlowAssign: () => this;
+
+        setName: (label: string) => Node;
+        setNameAssign: (label: string) => this;
     }
 }

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

@@ -1,10 +1,11 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export type IndexNodeScope =
     | typeof IndexNode.VERTEX
     | typeof IndexNode.INSTANCE
+    | typeof IndexNode.SUBGROUP
     | typeof IndexNode.INVOCATION_LOCAL
+    | typeof IndexNode.INVOCATION_SUBGROUP
     | typeof IndexNode.DRAW;
 
 declare class IndexNode extends Node {
@@ -16,15 +17,17 @@ declare class IndexNode extends Node {
 
     static VERTEX: "vertex";
     static INSTANCE: "instance";
+    static SUBGROUP: "subgroup";
     static INVOCATION_LOCAL: "invocationLocal";
+    static INVOCATION_SUBGROUP: "invocationSubgroup";
     static DRAW: "draw";
 }
 
 export default IndexNode;
 
-export const vertexIndex: ShaderNodeObject<IndexNode>;
-export const instanceIndex: ShaderNodeObject<IndexNode>;
-export const subgroupIndex: ShaderNodeObject<IndexNode>;
-export const invocationSubgroupIndex: ShaderNodeObject<IndexNode>;
-export const invocationLocalIndex: ShaderNodeObject<IndexNode>;
-export const drawIndex: ShaderNodeObject<IndexNode>;
+export const vertexIndex: IndexNode;
+export const instanceIndex: IndexNode;
+export const subgroupIndex: IndexNode;
+export const invocationSubgroupIndex: IndexNode;
+export const invocationLocalIndex: IndexNode;
+export const drawIndex: IndexNode;

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

@@ -0,0 +1,16 @@
+import Node from "./Node.js";
+
+declare class InspectorNode extends Node {
+    constructor(node: Node, name?: string, callback?: (node: Node) => Node);
+}
+
+export default InspectorNode;
+
+export function inspector<T extends Node>(node: T, name?: string, callback?: (node: T) => Node): T;
+
+declare module "../Nodes.js" {
+    interface Node {
+        toInspector: (name?: string, callback?: (node: this) => Node) => this;
+        toInspectorAssign: (name?: string, callback?: (node: this) => Node) => this;
+    }
+}

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

@@ -0,0 +1,36 @@
+import Node from "./Node.js";
+import NodeCache from "./NodeCache.js";
+
+declare class IsolateNode extends Node {
+    node: Node;
+    parent: boolean;
+
+    readonly isIsolateNode: true;
+
+    constructor(node: Node, parent?: boolean);
+}
+
+export default IsolateNode;
+
+export const isolate: (node: Node) => IsolateNode;
+
+/**
+ * @deprecated "cache()" has been deprecated. Use "isolate()" instead.
+ */
+export const cache: (node: Node, cache?: NodeCache) => IsolateNode;
+
+declare module "../Nodes.js" {
+    interface Node {
+        /**
+         * @deprecated "cache()" has been deprecated. Use "isolate()" instead.
+         */
+        cache: (cache?: NodeCache) => IsolateNode;
+        /**
+         * @deprecated "cache()" has been deprecated. Use "isolate()" instead.
+         */
+        cacheAssign: (cache?: NodeCache) => this;
+
+        isolate: () => IsolateNode;
+        isolateAssign: () => this;
+    }
+}

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

@@ -1,6 +1,5 @@
 import { Texture } from "../../textures/Texture.js";
 import { Node } from "../Nodes.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import OutputStructNode from "./OutputStructNode.js";
 
 export function getTextureIndex(textures: ReadonlyArray<Texture>, name: string): number;
@@ -14,11 +13,11 @@ declare class MRTNode extends OutputStructNode {
 
     has(name: string): boolean;
 
-    get(name: string): Node;
+    get: (name: string) => Node;
 
-    merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
+    merge(mrtNode: MRTNode): MRTNode;
 }
 
 export default MRTNode;
 
-export const mrt: (outputNodes: { [name: string]: Node }) => ShaderNodeObject<MRTNode>;
+export const mrt: (outputNodes: { [name: string]: Node }) => MRTNode;

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

@@ -57,6 +57,11 @@ interface NodeJSONOutputData {
     images?: unknown[];
     nodes?: NodeJSONOutputData[];
 }
+export interface NodeChild {
+    property: string;
+    index?: number | string;
+    childNode: Node;
+}
 /**
  * Base class for all nodes.
  *
@@ -72,6 +77,7 @@ declare class Node extends EventDispatcher<{
     updateAfterType: NodeUpdateType;
     uuid: string;
     version: number;
+    name: string | null;
     _cacheKey: number | null;
     _cacheKeyVersion: number;
     global: boolean;
@@ -180,13 +186,22 @@ declare class Node extends EventDispatcher<{
      * @param {traverseCallback} callback - A callback that is executed per node.
      */
     traverse(callback: (node: Node) => void): void;
+    /**
+     * Returns the child nodes of this node.
+     *
+     * @private
+     * @param {Set<Node>} [ignores=new Set()] - A set of nodes to ignore during the search to avoid circular references.
+     * @returns {Array<Object>} An array of objects describing the child nodes.
+     */
+    _getChildren(ignores?: Set<Node>): NodeChild[];
     /**
      * Returns the cache key for this node.
      *
      * @param {boolean} [force=false] - When set to `true`, a recomputation of the cache key is forced.
+     * @param {Set<Node>} [ignores=null] - A set of nodes to ignore during the computation of the cache key.
      * @return {number} The cache key of the node.
      */
-    getCacheKey(force?: boolean): number;
+    getCacheKey(force?: boolean, ignores?: Set<Node> | null): number;
     /**
      * Generate a custom cache key for this node.
      *
@@ -320,6 +335,7 @@ declare class Node extends EventDispatcher<{
      * @return {?boolean} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
      */
     update(frame: NodeFrame): void;
+    before(node: Node): this;
     /**
      * This method performs the build of a node. The behavior and return value depend on the current build stage:
      * - **setup**: Prepares the node and its children for the build process. This process can also create new nodes. Returns the node itself or a variant.
@@ -336,7 +352,7 @@ declare class Node extends EventDispatcher<{
      *
      * @return {Generator<Object>} An iterable list of serialized child objects as JSON.
      */
-    getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;
+    getSerializeChildren(): NodeChild[];
     /**
      * Serializes the node to JSON.
      *

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

@@ -6,20 +6,10 @@ 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 const hashString: (str: string) => number;
 export const hashArray: (array: number[]) => number;
 export const hash: (...params: number[]) => number;
 
-export function getCacheKey(object: Node, force?: boolean): number;
-
-export function getNodeChildren(object: Node): Generator<NodeChild, void>;
-
 export function getTypeFromLength(length: number): string | undefined;
 
 export function getLengthFromType(type: string): number | undefined;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class OutputStructNode extends Node {
@@ -9,4 +8,4 @@ export default class OutputStructNode extends Node {
     constructor(...members: Node[]);
 }
 
-export const outputStruct: (...members: Node[]) => ShaderNodeObject<OutputStructNode>;
+export const outputStruct: (...members: Node[]) => OutputStructNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import PropertyNode from "./PropertyNode.js";
 
 declare class ParameterNode extends PropertyNode {
@@ -9,4 +8,4 @@ declare class ParameterNode extends PropertyNode {
 
 export default ParameterNode;
 
-export const parameter: (type: string, name?: string | null) => ShaderNodeObject<ParameterNode>;
+export const parameter: (type: string, name?: string | null) => ParameterNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class PropertyNode extends Node {
@@ -10,34 +9,34 @@ export default class PropertyNode extends Node {
     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 property: (type?: string | null, name?: string | null) => PropertyNode;
+export const varyingProperty: (type?: string | null, name?: string | null) => 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>;
+export const diffuseColor: PropertyNode;
+export const emissive: PropertyNode;
+export const roughness: PropertyNode;
+export const metalness: PropertyNode;
+export const clearcoat: PropertyNode;
+export const clearcoatRoughness: PropertyNode;
+export const sheen: PropertyNode;
+export const sheenRoughness: PropertyNode;
+export const iridescence: PropertyNode;
+export const iridescenceIOR: PropertyNode;
+export const iridescenceThickness: PropertyNode;
+export const alphaT: PropertyNode;
+export const anisotropy: PropertyNode;
+export const anisotropyT: PropertyNode;
+export const anisotropyB: PropertyNode;
+export const specularColor: PropertyNode;
+export const specularF90: PropertyNode;
+export const shininess: PropertyNode;
+export const output: PropertyNode;
+export const dashSize: PropertyNode;
+export const gapSize: PropertyNode;
+export const pointWidth: PropertyNode;
+export const ior: PropertyNode;
+export const transmission: PropertyNode;
+export const thickness: PropertyNode;
+export const attenuationDistance: PropertyNode;
+export const attenuationColor: PropertyNode;
+export const dispersion: PropertyNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class StackNode extends Node {
@@ -8,8 +7,6 @@ declare class StackNode extends Node {
 
     constructor();
 
-    add(node: Node): this;
-
     If(boolNode: Node, method: () => void): this;
 
     ElseIf(boolNode: Node, method: () => void): this;
@@ -25,4 +22,4 @@ declare class StackNode extends Node {
 
 export default StackNode;
 
-export const stack: () => ShaderNodeObject<StackNode>;
+export const stack: () => StackNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import StructTypeNode, { MembersLayout } from "./StructTypeNode.js";
 
@@ -11,9 +10,9 @@ declare class StructNode extends Node {
 export default StructNode;
 
 export interface Struct {
-    (): ShaderNodeObject<StructNode>;
-    (values: Node[]): ShaderNodeObject<StructNode>;
-    (...values: Node[]): ShaderNodeObject<StructNode>;
+    (): StructNode;
+    (values: Node[]): StructNode;
+    (...values: Node[]): StructNode;
     layout: StructTypeNode;
     isStruct: true;
 }

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class SubBuildNode extends Node {
@@ -12,4 +11,4 @@ declare class SubBuildNode extends Node {
 
 export default SubBuildNode;
 
-export const subBuild: (node: Node, name: string, type?: string | null) => ShaderNodeObject<SubBuildNode>;
+export const subBuild: (node: Node, name: string, type?: string | null) => SubBuildNode;

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

@@ -27,7 +27,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
-    setName(name: string): this;
+    setName: (name: string) => this;
     /**
      * Sets the {@link UniformNode#name} property.
      *
@@ -35,7 +35,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
-    label(name: string): this;
+    label: (name: string) => this;
     /**
      * Sets the {@link UniformNode#groupNode} property.
      *
@@ -71,7 +71,4 @@ export default UniformNode;
  * @param {string} [type] - The node type. If no explicit type is defined, the node tries to derive the type from its value.
  * @returns {UniformNode}
  */
-export declare const uniform: <TValue>(
-    value: InputNode<TValue> | TValue,
-    type?: Node | string,
-) => import("../tsl/TSLCore.js").ShaderNodeObject<UniformNode<TValue>>;
+export declare const uniform: <TValue>(value: InputNode<TValue> | TValue, type?: Node | string) => UniformNode<TValue>;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class VarNode extends Node {
@@ -19,16 +18,21 @@ declare class VarNode extends Node {
 
 export default VarNode;
 
-export const Var: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+export const Var: (node: Node, name?: string | null) => VarNode;
 
-export const Const: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
+export const Const: (node: Node, name?: string | null) => VarNode;
 
 export const VarIntent: (node: Node) => Node;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toVar: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-        toConst: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-        toVarIntent: (node: Node) => Node;
+declare module "../Nodes.js" {
+    interface Node {
+        toVar: (name?: string | null) => VarNode;
+        toVarAssign: (name?: string | null) => this;
+
+        toConst: (name?: string | null) => VarNode;
+        toConstAssign: (name?: string | null) => this;
+
+        toVarIntent: () => Node;
+        toVarIntentAssign: () => this;
     }
 }

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

@@ -1,5 +1,4 @@
 import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeVarying from "./NodeVarying.js";
@@ -18,22 +17,25 @@ export default class VaryingNode extends Node {
     setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
-export const varying: (node: Node, name?: string) => ShaderNodeObject<VaryingNode>;
+export const varying: (node: Node, name?: string) => VaryingNode;
 
-export const vertexStage: (node: Node) => ShaderNodeObject<VaryingNode>;
+export const vertexStage: (node: Node) => VaryingNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toVarying: typeof varying;
-        toVertexStage: typeof vertexStage;
+declare module "../Nodes.js" {
+    interface Node {
+        toVarying: (name?: string) => VaryingNode;
+        toVaryingAssign: (name?: string) => this;
+
+        toVertexStage: () => VaryingNode;
+        toVertexStageAssign: () => this;
 
         /**
-         * @deprecated .varying() has been renamed to .toVarying().
+         * @deprecated .vertexStage() has been renamed to .toVertexStage().
          */
-        varying: typeof varying;
+        vertexStage: () => VaryingNode;
         /**
          * @deprecated .vertexStage() has been renamed to .toVertexStage().
          */
-        vertexStage: typeof vertexStage;
+        vertexStageAssign: () => this;
     }
 }

three/src/nodes/display/BlendModes.d.ts

@@ -1,36 +1,35 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const blendBurn: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendBurn: (base: Node, blend: Node) => Node;
 
-export const blendDodge: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendDodge: (base: Node, blend: Node) => Node;
 
-export const blendScreen: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendScreen: (base: Node, blend: Node) => Node;
 
-export const blendOverlay: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendOverlay: (base: Node, blend: Node) => Node;
 
-export const blendColor: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const blendColor: (base: Node, blend: Node) => Node;
 
-export const premultiplyAlpha: (color: Node) => ShaderNodeObject<Node>;
+export const premultiplyAlpha: (color: Node) => Node;
 
-export const unpremultiplyAlpha: (color: Node) => ShaderNodeObject<Node>;
+export const unpremultiplyAlpha: (color: Node) => Node;
 
 /**
  * @deprecated
  */
-export const burn: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const burn: (base: Node, blend: Node) => Node;
 
 /**
  * @deprecated
  */
-export const dodge: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const dodge: (base: Node, blend: Node) => Node;
 
 /**
  * @deprecated
  */
-export const screen: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const screen: (base: Node, blend: Node) => Node;
 
 /**
  * @deprecated
  */
-export const overlay: (base: Node, blend: Node) => ShaderNodeObject<Node>;
+export const overlay: (base: Node, blend: Node) => Node;

three/src/nodes/display/BumpMapNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class BumpMapNode extends TempNode {
     textureNode: Node;
@@ -14,4 +13,4 @@ export default BumpMapNode;
 export const bumpMap: (
     textureNode: Node,
     scaleNode?: Node | null,
-) => ShaderNodeObject<BumpMapNode>;
+) => BumpMapNode;

three/src/nodes/display/ColorAdjustment.d.ts

@@ -1,30 +1,29 @@
 import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const grayscale: (color: Node) => ShaderNodeObject<Node>;
+export const grayscale: (color: Node) => Node;
 
 export const saturation: (
     color: Node,
     adjustment?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const vibrance: (
     color: Node,
     adjustment?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const hue: (
     color: Node,
     adjustment?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const luminance: (
     color: Node,
     luminanceCoefficients?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
-export const threshold: (color: Node, thershold: Node) => ShaderNodeObject<MathNode>;
+export const threshold: (color: Node, thershold: Node) => MathNode;
 
 /**
  * Color Decision List (CDL) v1.2
@@ -53,4 +52,4 @@ export const cdl: (
     power?: Node,
     saturation?: Node,
     luminanceCoefficients?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/display/ColorSpaceFunctions.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const sRGBTransferEOTF: (color: Node) => ShaderNodeObject<Node>;
+export const sRGBTransferEOTF: (color: Node) => Node;
 
-export const sRGBTransferOETF: (color: Node) => ShaderNodeObject<Node>;
+export const sRGBTransferOETF: (color: Node) => Node;