@types/three 0.165.0 → 0.167.0

three/{examples/jsm → src}/nodes/core/NodeCache.d.ts

@@ -1,3 +1,6 @@
+import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import BufferAttributeNode from "../accessors/BufferAttributeNode.js";
 import Node from "./Node.js";
 import NodeAttribute from "./NodeAttribute.js";
 import NodeCode from "./NodeCode.js";
@@ -33,11 +36,17 @@ interface NodeData {
     compute?: ShaderStageNodeData | undefined;
     any?: ShaderStageNodeData | undefined;
 }
+interface BufferAttributeData {
+    node: BufferAttributeNode;
+}
 declare class NodeCache {
     id: number;
-    nodesData: WeakMap<Node, NodeData>;
-    constructor();
-    getNodeData(node: Node): NodeData | undefined;
-    setNodeData(node: Node, data: NodeData): void;
+    nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
+    parent: NodeCache | null;
+    constructor(parent?: NodeCache | null);
+    getData(node: Node): NodeData | undefined;
+    getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+    setData(node: Node, data: NodeData): void;
+    setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
 }
 export default NodeCache;

three/{examples/jsm → src}/nodes/core/NodeFrame.d.ts

@@ -1,5 +1,8 @@
-import { Camera, Material, Object3D, Renderer, Scene } from "three";
-
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Scene } from "../../scenes/Scene.js";
 import Node from "./Node.js";
 
 export default class NodeFrame {

three/{examples/jsm → src}/nodes/core/NodeFunction.d.ts

@@ -5,9 +5,9 @@ export default abstract class NodeFunction {
     type: string;
     inputs: NodeFunctionInput[];
     name: string;
-    presicion: string;
+    precision: string;
 
-    constructor(type: string, inputs: NodeFunctionInput[], name?: string, presicion?: string);
+    constructor(type: string, inputs: NodeFunctionInput[], name?: string, precision?: string);
 
     abstract getCode(name?: string): string;
 }

three/{examples/jsm → src}/nodes/core/NodeUniform.d.ts

@@ -5,7 +5,7 @@ declare class NodeUniform<TValue> {
     type: string | null;
     node: UniformNode<TValue>;
     needsUpdate: boolean | undefined;
-    constructor(name: string, type: string | null, node: UniformNode<TValue>, needsUpdate?: undefined);
+    constructor(name: string, type: string | null, node: UniformNode<TValue>);
     get value(): TValue;
     set value(val: TValue);
     get id(): number;

three/{examples/jsm → src}/nodes/core/NodeUtils.d.ts

@@ -1,4 +1,9 @@
-import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from "three";
+import { Color } from "../../math/Color.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import Node from "./Node.js";
 
 export interface NodeChild {

three/{examples/jsm → src}/nodes/core/PropertyNode.d.ts

@@ -14,6 +14,7 @@ export const property: (type?: string | null, name?: string | null) => ShaderNod
 export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<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>;

three/{examples/jsm → src}/nodes/core/UniformNode.d.ts

@@ -6,8 +6,10 @@ import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
 declare class UniformNode<TValue> extends InputNode<TValue> {
     readonly isUniformNode: true;
+    name: string;
     groupNode: UniformGroupNode;
     constructor(value: TValue, nodeType?: string | null);
+    label(name: string): this;
     setGroup(group: UniformGroupNode): this;
     getGroup(): UniformGroupNode;
     getUniformHash(builder: NodeBuilder): string;

three/{examples/jsm → src}/nodes/core/VarNode.d.ts

@@ -6,6 +6,8 @@ export default class VarNode extends Node {
     node: Node;
     name: string | null;
 
+    readonly isVarNode: true;
+
     constructor(node: Node, name?: string | null);
 
     op(op: OperatorNodeOp, ...params: Node[]): this;

three/{examples/jsm → src}/nodes/display/AnamorphicNode.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from "three";
+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";

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

@@ -0,0 +1,35 @@
+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 { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class BloomNode extends TempNode {
+    inputNode: Node;
+    strength: UniformNode<number>;
+    radius: UniformNode<number>;
+    threshold: UniformNode<number>;
+
+    smoothWidth: UniformNode<number>;
+
+    constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
+
+    getTexture(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const bloom: (
+    node: NodeRepresentation,
+    strength?: number,
+    radius?: number,
+    threshold?: number,
+) => ShaderNodeObject<BloomNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        bloom: typeof bloom;
+    }
+}
+
+export default BloomNode;

three/{examples/jsm → src}/nodes/display/ColorAdjustmentNode.d.ts

@@ -33,7 +33,6 @@ export const hue: (
     adjustmentNode?: NodeRepresentation,
 ) => ShaderNodeObject<ColorAdjustmentNode>;
 
-export const lumaCoeffs: ShaderNodeObject<MathNode>;
 export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;

three/{examples/jsm → src}/nodes/display/ColorSpaceNode.d.ts

@@ -1,4 +1,4 @@
-import { ColorSpace } from "three";
+import { ColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";

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

@@ -0,0 +1,38 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class DenoiseNode extends TempNode {
+    textureNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+    noiseNode: Node;
+
+    cameraProjectionMatrixInversion: UniformNode<Matrix4>;
+    lumaPhi: UniformNode<number>;
+    depthPhi: UniformNode<number>;
+    normalPhi: UniformNode<number>;
+    radius: UniformNode<number>;
+    index: UniformNode<number>;
+
+    constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
+}
+
+export const denoise: (
+    node: NodeRepresentation,
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    noiseNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<DenoiseNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        denoise: typeof denoise;
+    }
+}
+
+export default DenoiseNode;

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

@@ -0,0 +1,30 @@
+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 { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DepthOfFieldNode extends TempNode {
+    textureNode: TextureNode;
+    viewZNode: Node;
+
+    focus: UniformNode<number>;
+    aperture: UniformNode<number>;
+    maxblur: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
+}
+
+export const dof: (
+    node: NodeRepresentation,
+    viewZNode: NodeRepresentation,
+    focus?: NodeRepresentation,
+    aperture?: NodeRepresentation,
+    maxblur?: NodeRepresentation,
+) => ShaderNodeObject<DepthOfFieldNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        dof: typeof dof;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Vector2 } from "../../math/Vector2.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DotScreenNode extends TempNode {
+    inputNode: Node;
+    center: UniformNode<Vector2>;
+    angle: UniformNode<number>;
+    scale: UniformNode<number>;
+
+    constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
+}
+
+export const dotScreen: (
+    node: NodeRepresentation,
+    center?: Vector2,
+    angle?: number,
+    scale?: number,
+) => ShaderNodeObject<DotScreenNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        dotScreen: typeof dotScreen;
+    }
+}

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

@@ -0,0 +1,19 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class FXAANode extends TempNode {
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+}
+
+export const fxaa: (node: NodeRepresentation) => ShaderNodeObject<FXAANode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        fxaa: typeof fxaa;
+    }
+}
+
+export default FXAANode;

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

@@ -0,0 +1,25 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class FilmNode extends TempNode {
+    inputNode: Node;
+    intensityNode: Node | null;
+    uvNode: Node | null;
+
+    constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
+}
+
+export const film: (
+    inputNode: NodeRepresentation,
+    intensityNode?: NodeRepresentation | null,
+    uvNode?: NodeRepresentation | null,
+) => ShaderNodeObject<FilmNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        film: typeof film;
+    }
+}
+
+export default FilmNode;

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

@@ -0,0 +1,46 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
+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 { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class GTAONode extends TempNode {
+    depthNode: Node;
+    normalNode: Node;
+
+    radius: ShaderNodeObject<UniformNode<number>>;
+    resolution: ShaderNodeObject<UniformNode<Vector2>>;
+    thickness: ShaderNodeObject<UniformNode<number>>;
+    distanceExponent: ShaderNodeObject<UniformNode<number>>;
+    distanceFallOff: ShaderNodeObject<UniformNode<number>>;
+    scale: ShaderNodeObject<UniformNode<number>>;
+    noiseNode: ShaderNodeObject<TextureNode>;
+
+    cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+    cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+
+    SAMPLES: ShaderNodeObject<UniformNode<number>>;
+
+    constructor(depthNode: Node, normalNode: Node, camera: Camera);
+
+    getTextureNode(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const ao: (
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<GTAONode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        ao: typeof ao;
+    }
+}
+
+export default GTAONode;

three/{examples/jsm → src}/nodes/display/GaussianBlurNode.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from "three";
+import { Vector2 } from "../../math/Vector2.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
@@ -6,20 +6,23 @@ import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.j
 
 export default class GaussianBlurNode extends TempNode {
     textureNode: TextureNode;
+    directionNode: Node | null;
     sigma: number;
 
-    directionNode: Node;
-
     resolution: Vector2;
 
-    constructor(textureNode: TextureNode, sigma?: number);
+    constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
 
     setSize(width: number, height: number): void;
 
     getTextureNode(): TextureNode;
 }
 
-export const gaussianBlur: (node: NodeRepresentation, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
+export const gaussianBlur: (
+    node: NodeRepresentation,
+    directionNode?: NodeRepresentation | null,
+    sigma?: number,
+) => ShaderNodeObject<GaussianBlurNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -0,0 +1,30 @@
+import { Data3DTexture } from "../../textures/Data3DTexture.js";
+import Texture3DNode from "../accessors/Texture3DNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class Lut3DNode extends TempNode {
+    inputNode: Node;
+    lutNode: Texture3DNode;
+    size: ShaderNodeObject<UniformNode<number>>;
+    intensityNode: UniformNode<number>;
+
+    constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
+}
+
+export const lut3D: (
+    node: NodeRepresentation,
+    lut: NodeRepresentation,
+    size: number,
+    intensity: NodeRepresentation,
+) => ShaderNodeObject<Lut3DNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        lut3D: typeof lut3D;
+    }
+}
+
+export default Lut3DNode;

three/{examples/jsm → src}/nodes/display/NormalMapNode.d.ts

@@ -1,7 +1,6 @@
-import { NormalMapTypes } from "three";
+import { NormalMapTypes } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class NormalMapNode extends TempNode {

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

@@ -0,0 +1,62 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Scene } from "../../scenes/Scene.js";
+import { Texture } from "../../textures/Texture.js";
+import TextureNode from "../accessors/TextureNode.js";
+import MRTNode from "../core/MRTNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class PassTextureNode extends TextureNode {
+    passNode: PassNode;
+
+    constructor(passNode: PassNode, texture: Texture);
+}
+
+declare class PassMultipleTextureNode extends PassTextureNode {
+    textureName: string;
+
+    constructor(passNode: PassNode, textureName: string);
+}
+
+declare class PassNode extends TempNode {
+    scope: PassNodeScope;
+    scene: Scene;
+    camera: Camera;
+
+    renderTarget: RenderTarget;
+
+    readonly isPassNode: true;
+
+    constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
+
+    setMRT(mrt: MRTNode | null): this;
+
+    getMRT(): MRTNode | null;
+
+    getTexture(name: string): Texture;
+
+    getTextureNode(name?: string): ShaderNodeObject<Node>;
+
+    getViewZNode(name?: string): ShaderNodeObject<Node>;
+
+    getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
+
+    setSize(width: number, height: number): void;
+
+    setPixelRatio(pixelRatio: number): void;
+
+    dispose(): void;
+
+    static COLOR: "color";
+    static DEPTH: "depth";
+}
+
+export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
+
+export default PassNode;
+
+export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
+export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
+export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

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

@@ -0,0 +1,67 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Scene } from "../../scenes/Scene.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import PassNode from "./PassNode.js";
+
+declare class PixelationNode extends TempNode {
+    textureNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+
+    pixelSize: Node;
+    normalEdgeStrength: Node;
+    depthEdgeStrength: Node;
+
+    constructor(
+        textureNode: Node,
+        depthNode: Node,
+        normalNode: Node,
+        pixelSize: Node,
+        normalEdgeStrength: Node,
+        depthEdgeStrength: Node,
+    );
+}
+
+declare const pixelation: (
+    node: NodeRepresentation,
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    pixelSize?: number,
+    normalEdgeStrength?: number,
+    depthEdgeStrength?: number,
+) => ShaderNodeObject<PixelationNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        pixelation: typeof pixelation;
+    }
+}
+
+declare class PixelationPassNode extends PassNode {
+    pixelSize: UniformNode<number>;
+    normalEdgeStrength: UniformNode<number>;
+    depthEdgeStrength: UniformNode<number>;
+
+    readonly isPixelationPassNode: true;
+
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        pixelSize: number,
+        normalEdgeStrength: number,
+        depthEdgeStrength: number,
+    );
+}
+
+export const pixelationPass: (
+    scene: Scene,
+    camera: Camera,
+    pixelSize: UniformNode<number>,
+    normalEdgeStrength: UniformNode<number>,
+    depthEdgeStrength: UniformNode<number>,
+) => ShaderNodeObject<PixelationPassNode>;
+
+export default PixelationPassNode;

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

@@ -0,0 +1,24 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class RGBShiftNode extends TempNode {
+    textureNode: TextureNode;
+    amount: UniformNode<number>;
+    angle: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, amount?: number, angle?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        rgbShift: typeof rgbShift;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { ColorSpace, ToneMapping } from "../../constants.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class RenderOutputNode extends TempNode {
+    colorNode: Node;
+    toneMapping: ToneMapping | null;
+    outputColorSpace: ColorSpace | null;
+
+    readonly isRenderOutput: true;
+
+    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
+}
+
+export default RenderOutputNode;
+
+export const renderOutput: (
+    color: NodeRepresentation,
+    toneMapping?: ToneMapping | null,
+    outputColorSpace?: ColorSpace | null,
+) => ShaderNodeObject<RenderOutputNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        renderOutput: typeof renderOutput;
+    }
+}

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

@@ -0,0 +1,17 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class SobelOperatorNode extends TempNode {
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+}
+
+export const sobel: (node: NodeRepresentation) => ShaderNodeObject<SobelOperatorNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        sobel: typeof sobel;
+    }
+}

three/{examples/jsm → src}/nodes/display/ToneMappingNode.d.ts

@@ -1,4 +1,4 @@
-import { ToneMapping } from "three";
+import { ToneMapping } from "../../constants.js";
 import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";