@types/three 0.167.2 → 0.169.0

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

@@ -1,7 +1,7 @@
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class TextureNode extends UniformNode<Texture> {
     readonly isTextureNode: true;
@@ -27,8 +27,26 @@ export default class TextureNode extends UniformNode<Texture> {
 
     getDefaultUV(): Node;
 
+    setSampler(value: boolean): this;
+
+    getSampler(): boolean;
+
+    uv(uvNode: NodeRepresentation): ShaderNodeObject<Node>;
+
+    blur(amountNode: NodeRepresentation): ShaderNodeObject<Node>;
+
+    level(levelNode: NodeRepresentation): ShaderNodeObject<Node>;
+
+    size(levelNode: NodeRepresentation): ShaderNodeObject<Node>;
+
+    bias(biasNode: NodeRepresentation): ShaderNodeObject<Node>;
+
+    compare(compareNode: NodeRepresentation): ShaderNodeObject<Node>;
+
     grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
 
+    depth(depthNode: NodeRepresentation): ShaderNodeObject<Node>;
+
     clone(): this;
 }
 
@@ -38,10 +56,11 @@ export const texture: (
     levelNode?: NodeRepresentation,
     biasNode?: NodeRepresentation,
 ) => ShaderNodeObject<TextureNode>;
-export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
+export const textureLoad: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+    biasNode?: NodeRepresentation,
+) => ShaderNodeObject<TextureNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        texture: typeof texture;
-    }
-}
+export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;

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

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

three/src/nodes/accessors/{UVNode.d.ts → UV.d.ts}

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

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

@@ -0,0 +1,30 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import ArrayElementNode from "../utils/ArrayElementNode.js";
+import BufferNode from "./BufferNode.js";
+
+declare class UniformArrayElementNode extends ArrayElementNode {
+    constructor(arrayBuffer: Node, indexNode: Node);
+}
+
+declare class UniformArrayNode extends BufferNode {
+    array: unknown[];
+    elementType: string | null;
+
+    readonly isArrayBufferNode: true;
+
+    constructor(value: unknown[], elementType?: string | null);
+
+    getElementLength(): number;
+
+    element(indexNode: number): ShaderNodeObject<UniformArrayElementNode>;
+}
+
+export default UniformArrayNode;
+
+export const uniformArray: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformArrayNode>;
+
+/**
+ * @deprecated uniforms() has been renamed to uniformArray().
+ */
+export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformArrayNode>;

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

@@ -1,4 +1,4 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export type NodeUserData = Record<string, any>;

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

@@ -0,0 +1,16 @@
+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 {
+    previousModelWorldMatrix: UniformNode<Matrix4>;
+    previousProjectionMatrix: UniformNode<Matrix4>;
+    previousCameraViewMatrix: UniformNode<Matrix4>;
+
+    constructor();
+}
+
+export default VelocityNode;
+
+export const velocity: ShaderNodeObject<VelocityNode>;

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

@@ -1,5 +1,5 @@
 import AttributeNode from "../core/AttributeNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class VertexColorNode extends AttributeNode {
     readonly isVertexColorNode: true;

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;

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

@@ -1,5 +1,5 @@
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ExpressionNode extends TempNode {
     snipped: string; /* sic */

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 "../shadernode/ShaderNode.js";
+import { ProxiedObject, ShaderNodeObject } from "../tsl/TSLCore.js";
 import FunctionNode, { FunctionNodeArguments } from "./FunctionNode.js";
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
@@ -18,7 +18,7 @@ export const call: <P extends FunctionNodeArguments>(
     parameters?: ProxiedObject<P>,
 ) => ShaderNodeObject<FunctionCallNode<P>>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         call: typeof call;
     }

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

@@ -2,14 +2,13 @@ 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 "../shadernode/ShaderNode.js";
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from "../tsl/TSLCore.js";
 import CodeNode, { CodeNodeInclude } from "./CodeNode.js";
 import FunctionCallNode from "./FunctionCallNode.js";
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
 export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
-    keywords: { [key: string]: Node };
     constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];
@@ -17,7 +16,7 @@ export default class FunctionNode<P extends Node[] | { [name: string]: Node }> e
     call(parameters: P): FunctionCallNode<P>;
 }
 
-export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
+type FnParameters<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
     : readonly [ProxiedObject<P>];
 
 export const nativeFn: <P extends FunctionNodeArguments>(
@@ -25,15 +24,15 @@ export const nativeFn: <P extends FunctionNodeArguments>(
     includes?: CodeNodeInclude[],
     language?: string,
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: Fn<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
 
 export const glslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: Fn<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
 export const wgslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: Fn<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;

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

@@ -0,0 +1,22 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, 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;
+}
+
+export const global: Resources;
+
+declare class ScriptableNode extends Node {
+    codeNode: Node | null;
+    parameters: Record<string, unknown>;
+
+    constructor(codeNode?: Node | null, parameters?: Record<string, unknown>);
+}
+
+export default ScriptableNode;
+
+export const scriptable: (
+    codeNode?: NodeRepresentation | null,
+    parameters?: Record<string, unknown>,
+) => ShaderNodeObject<ScriptableNode>;

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

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

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

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import TempNode from "./TempNode.js";
@@ -11,7 +11,7 @@ export default class AssignNode extends TempNode {
 
 export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         assign: typeof assign;
     }

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

@@ -1,11 +1,9 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
 export default class AttributeNode extends Node {
-    defaultNode: Node | null;
-
-    constructor(attributeName: string, nodeType?: string | null, defaultNode?: Node | null);
+    constructor(attributeName: string, nodeType?: string | null);
 
     setAttributeName(attributeName: string): this;
 
@@ -15,5 +13,4 @@ export default class AttributeNode extends Node {
 export const attribute: (
     name: string,
     nodeType?: string | null,
-    defaultNode?: NodeRepresentation,
 ) => ShaderNodeObject<AttributeNode>;

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

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class BypassNode extends Node {
@@ -11,7 +11,7 @@ export default class BypassNode extends Node {
 
 export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         bypass: typeof bypass;
     }

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

@@ -1,4 +1,4 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeCache from "./NodeCache.js";
 
@@ -13,7 +13,7 @@ export default class CacheNode extends Node {
 
 export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         cache: typeof cache;
     }

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

@@ -1,19 +1,22 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import { NodeBuilderContext } from "./NodeBuilder.js";
 
-export default class ContextNode extends Node {
-    isContextNode: true;
+declare class ContextNode extends Node {
+    readonly isContextNode: true;
+
     node: Node;
-    context: NodeBuilderContext;
+    value: NodeBuilderContext;
 
-    constructor(node: Node, context: NodeBuilderContext);
+    constructor(node: Node, value?: NodeBuilderContext);
 }
 
-export const context: (node: NodeRepresentation, context: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
+export default ContextNode;
+
+export const context: (node: NodeRepresentation, context?: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
 export const label: (node: NodeRepresentation, label: string) => ShaderNodeObject<ContextNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         context: typeof context;
         label: typeof label;

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

@@ -1,9 +1,13 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
-export type IndexNodeScope = typeof IndexNode.VERTEX | typeof IndexNode.INSTANCE | typeof IndexNode.DRAW;
+export type IndexNodeScope =
+    | typeof IndexNode.VERTEX
+    | typeof IndexNode.INSTANCE
+    | typeof IndexNode.INVOCATION_LOCAL
+    | typeof IndexNode.DRAW;
 
-export default class IndexNode extends Node {
+declare class IndexNode extends Node {
     scope: IndexNodeScope;
 
     readonly isInstanceNode: true;
@@ -12,9 +16,13 @@ export default class IndexNode extends Node {
 
     static VERTEX: "vertex";
     static INSTANCE: "instance";
+    static INVOCATION_LOCAL: "invocationLocal";
     static DRAW: "draw";
 }
 
+export default IndexNode;
+
 export const vertexIndex: ShaderNodeObject<IndexNode>;
 export const instanceIndex: ShaderNodeObject<IndexNode>;
+export const invocationLocalIndex: ShaderNodeObject<IndexNode>;
 export const drawIndex: ShaderNodeObject<IndexNode>;

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

@@ -1,7 +1,10 @@
+import { Texture } from "../../textures/Texture.js";
 import { Node } from "../Nodes.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import OutputStructNode from "./OutputStructNode.js";
 
+export function getTextureIndex(textures: ReadonlyArray<Texture>, name: string): number;
+
 declare class MRTNode extends OutputStructNode {
     outputNodes: { [name: string]: Node };
 
@@ -9,7 +12,9 @@ declare class MRTNode extends OutputStructNode {
 
     constructor(outputNodes: { [name: string]: Node });
 
-    getNode(name: string): Node;
+    has(name: string): boolean;
+
+    get(name: string): Node;
 
     merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
 }

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

@@ -60,13 +60,14 @@ interface NodeJSONOutputData {
 declare class Node extends EventDispatcher<{
     dispose: {};
 }> {
+    static get type(): string;
     nodeType: string | null;
     updateType: NodeUpdateType;
     updateBeforeType: NodeUpdateType;
     updateAfterType: NodeUpdateType;
     uuid: string;
     version: number;
-    _cacheKey: string | null;
+    _cacheKey: number | null;
     _cacheKeyVersion: number;
     global: boolean;
     readonly isNode: true;
@@ -86,7 +87,8 @@ declare class Node extends EventDispatcher<{
     getChildren(): Generator<Node, void, unknown>;
     dispose(): void;
     traverse(callback: (node: Node) => void): void;
-    getCacheKey(force?: boolean): string;
+    getCacheKey(force?: boolean): number;
+    getScope(): this;
     getHash(builder: NodeBuilder): string;
     getUpdateType(): NodeUpdateType;
     getUpdateBeforeType(): NodeUpdateType;
@@ -95,7 +97,6 @@ declare class Node extends EventDispatcher<{
     getNodeType(builder: NodeBuilder): string | null;
     getShared(builder: NodeBuilder): Node;
     setup(builder: NodeBuilder): unknown;
-    increaseUsage(builder: NodeBuilder): number;
     analyze(builder: NodeBuilder): void;
     generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
     updateBefore(frame: NodeFrame): void;
@@ -108,7 +109,3 @@ declare class Node extends EventDispatcher<{
     toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData;
 }
 export default Node;
-export declare function addNodeClass(type: string, nodeClass: {
-    new(...args: any[]): Node;
-}): void;
-export declare function createNodeFromType(type: string): Node | undefined;

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

@@ -12,7 +12,11 @@ export interface NodeChild {
     childNode: Node;
 }
 
-export function getCacheKey(object: Node, force?: boolean): string;
+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 getValueType(value: unknown): string | null;
 export function getValueFromType(

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

@@ -1,4 +1,4 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class OutputStructNode extends Node {

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

@@ -0,0 +1,12 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import PropertyNode from "./PropertyNode.js";
+
+declare class ParameterNode extends PropertyNode {
+    readonly isParameterNode: true;
+
+    constructor(nodeType: string, name?: string | null);
+}
+
+export default ParameterNode;
+
+export const parameter: (type: string, name?: string | null) => ShaderNodeObject<ParameterNode>;

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

@@ -1,4 +1,4 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class PropertyNode extends Node {

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

@@ -9,9 +9,19 @@ export default class StackNode extends Node {
 
     add(node: Node): this;
 
-    if(boolNode: Node, method: () => void): this;
+    If(boolNode: Node, method: () => void): this;
 
-    elseIf(node: Node, method: () => void): this;
+    ElseIf(node: Node, method: () => void): this;
 
+    Else(node: Node, method: () => void): this;
+
+    /**
+     * @deprecated Use {@link StackNode#ElseIf Else()} instead.
+     */
+    elseif(node: Node, method: () => void): this;
+
+    /**
+     * @deprecated Use {@link StackNode#Else Else()} instead.
+     */
     else(node: Node, method: () => void): this;
 }

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

@@ -1,5 +1,6 @@
 import Node from "./Node.js";
 declare class StructTypeNode extends Node {
+    static get type(): string;
     types: string[];
     readonly isStructTypeNode: true;
     constructor(types: string[]);

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

@@ -5,6 +5,7 @@ import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
 declare class UniformNode<TValue> extends InputNode<TValue> {
+    static get type(): string;
     readonly isUniformNode: true;
     name: string;
     groupNode: UniformGroupNode;
@@ -20,4 +21,4 @@ export default UniformNode;
 export declare const uniform: <TValue>(
     arg1: InputNode<TValue> | TValue,
     arg2?: Node | string,
-) => import("../shadernode/ShaderNode.js").ShaderNodeObject<UniformNode<TValue>>;
+) => import("../tsl/TSLCore.js").ShaderNodeObject<UniformNode<TValue>>;

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

@@ -1,5 +1,4 @@
-import { OperatorNodeOp } from "../math/OperatorNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class VarNode extends Node {
@@ -9,18 +8,11 @@ export default class VarNode extends Node {
     readonly isVarNode: true;
 
     constructor(node: Node, name?: string | null);
-
-    op(op: OperatorNodeOp, ...params: Node[]): this;
-    assign(...params: Node[]): this;
-    add(...params: Node[]): this;
-    sub(...params: Node[]): this;
-    mul(...params: Node[]): this;
-    div(...params: Node[]): this;
 }
 
 export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         temp: typeof temp;
         toVar: typeof temp;

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

@@ -1,4 +1,4 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeVarying from "./NodeVarying.js";
@@ -14,7 +14,7 @@ export default class VaryingNode extends Node {
 
 export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
 
-declare module "../shadernode/ShaderNode.js" {
+declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         varying: typeof varying;
     }

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

@@ -2,7 +2,7 @@ import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class AfterImageNode extends TempNode {
     textureNode: TextureNode;
@@ -17,9 +17,3 @@ export default class AfterImageNode extends TempNode {
 }
 
 export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        afterImage: typeof afterImage;
-    }
-}

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

@@ -0,0 +1,14 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Scene } from "../../scenes/Scene.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import StereoCompositePassNode from "./StereoCompositePassNode.js";
+
+declare class AnaglyphPassNode extends StereoCompositePassNode {
+    readonly isAnaglyphPassNode: true;
+
+    constructor(scene: Scene, camera: Camera);
+}
+
+export default AnaglyphPassNode;
+
+export const anaglyphPass: (scene: Scene, camera: Camera) => ShaderNodeObject<AnaglyphPassNode>;

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

@@ -1,7 +1,7 @@
 import { Vector2 } from "../../math/Vector2.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class AnamorphicNode extends TempNode {
     textureNode: Node;
@@ -23,9 +23,3 @@ export const anamorphic: (
     scale?: NodeRepresentation,
     samples?: NodeRepresentation,
 ) => ShaderNodeObject<AnamorphicNode>;
-
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        anamorphic: typeof anamorphic;
-    }
-}

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

@@ -0,0 +1,4 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const bleach: (color: NodeRepresentation, opacity?: number) => ShaderNodeObject<Node>;