@types/three 0.178.0 → 0.179.0

three/src/loaders/ImageBitmapLoader.d.ts

@@ -2,21 +2,21 @@ import { Loader } from "./Loader.js";
 import { LoadingManager } from "./LoadingManager.js";
 
 export class ImageBitmapLoader extends Loader<ImageBitmap> {
+    readonly isImageBitmapLoader: true;
+
+    /**
+     * @default { premultiplyAlpha: 'none' }
+     */
+    options: ImageBitmapOptions;
+
     constructor(manager?: LoadingManager);
 
+    setOptions(options: ImageBitmapOptions): this;
+
     load(
         url: string,
         onLoad?: (data: ImageBitmap) => void,
         onProgress?: (event: ProgressEvent) => void,
         onError?: (err: unknown) => void,
     ): void;
-
-    /**
-     * @default { premultiplyAlpha: 'none' }
-     */
-    options: undefined | object;
-
-    readonly isImageBitmapLoader: true;
-
-    setOptions(options: object): ImageBitmapLoader;
 }

three/src/loaders/Loader.d.ts

@@ -45,6 +45,7 @@ export class Loader<TData = unknown, TUrl = string> {
     setPath(path: string): this;
     setResourcePath(resourcePath: string): this;
     setRequestHeader(requestHeader: { [header: string]: string }): this;
+    abort(): this;
 
     static DEFAULT_MATERIAL_NAME: string;
 }

three/src/loaders/LoadingManager.d.ts

@@ -1,11 +1,9 @@
 import { Loader } from "./Loader.js";
 
-export const DefaultLoadingManager: LoadingManager;
-
 /**
  * Handles and keeps track of loaded and pending data.
  */
-export class LoadingManager {
+declare class LoadingManager {
     constructor(
         onLoad?: () => void,
         onProgress?: (url: string, loaded: number, total: number) => void,
@@ -18,7 +16,7 @@ export class LoadingManager {
      * @param loaded The number of items already loaded so far.
      * @param total The total amount of items to be loaded.
      */
-    onStart?: ((url: string, loaded: number, total: number) => void) | undefined;
+    onStart: ((url: string, loaded: number, total: number) => void) | undefined;
 
     /**
      * Will be called when all items finish loading.
@@ -42,28 +40,34 @@ export class LoadingManager {
      */
     onError: (url: string) => void;
 
-    /**
-     * If provided, the callback will be passed each resource URL before a request is sent.
-     * The callback may return the original URL, or a new URL to override loading behavior.
-     * This behavior can be used to load assets from .ZIP files, drag-and-drop APIs, and Data URIs.
-     * @param callback URL modifier callback. Called with url argument, and must return resolvedURL.
-     */
-    setURLModifier(callback?: (url: string) => string): this;
+    abortController: AbortController;
+
+    itemStart: (url: string) => void;
+    itemEnd: (url: string) => void;
+    itemError: (url: string) => void;
 
     /**
      * Given a URL, uses the URL modifier callback (if any) and returns a resolved URL.
      * If no URL modifier is set, returns the original URL.
      * @param url the url to load
      */
-    resolveURL(url: string): string;
+    resolveURL: (url: string) => string;
 
-    itemStart(url: string): void;
-    itemEnd(url: string): void;
-    itemError(url: string): void;
+    /**
+     * If provided, the callback will be passed each resource URL before a request is sent.
+     * The callback may return the original URL, or a new URL to override loading behavior.
+     * This behavior can be used to load assets from .ZIP files, drag-and-drop APIs, and Data URIs.
+     * @param callback URL modifier callback. Called with url argument, and must return resolvedURL.
+     */
+    setURLModifier: (callback?: (url: string) => string) => this;
 
-    // handlers
+    addHandler: (regex: RegExp, loader: Loader) => this;
+    removeHandler: (regex: RegExp) => this;
+    getHandler: (file: string) => Loader | null;
 
-    addHandler(regex: RegExp, loader: Loader): this;
-    removeHandler(regex: RegExp): this;
-    getHandler(file: string): Loader | null;
+    abort: () => this;
 }
+
+declare const DefaultLoadingManager: LoadingManager;
+
+export { DefaultLoadingManager, LoadingManager };

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -60,6 +60,18 @@ export interface MeshPhysicalMaterialProperties extends MeshStandardMaterialProp
      * @default 1.5
      */
     ior: number;
+    /**
+     * Degree of reflectivity, from `0.0` to `1.0`. Default is `0.5`, which
+     * corresponds to an index-of-refraction of `1.5`.
+     *
+     * This models the reflectivity of non-metallic materials. It has no effect
+     * when `metalness` is `1.0`
+     *
+     * @name MeshPhysicalMaterial#reflectivity
+     * @default 0.5
+     */
+    get reflectivity(): number;
+    set reflectivity(reflectivity: number);
     /**
      * The red channel of this texture is multiplied against `iridescence`, for per-pixel
      * control over iridescence.

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

@@ -16,12 +16,6 @@ export interface Line2NodeMaterialNodeProperties extends NodeMaterialNodePropert
      * @default 0
      */
     dashOffset: number;
-    /**
-     * The line width.
-     *
-     * @default 0
-     */
-    lineWidth: number;
     /**
      * Defines the lines color.
      *

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

@@ -7,6 +7,11 @@ export interface PointsNodeMaterialNodeProperties extends SpriteNodeMaterialNode
     /**
      * This node property provides an additional way to set the point size.
      *
+     * Note that WebGPU only supports point primitives with 1 pixel size. Consequently,
+     * this node has no effect when the material is used with {@link Points} and a WebGPU
+     * backend. If an application wants to render points with a size larger than 1 pixel,
+     * the material should be used with {@link Sprite} and instancing.
+     *
      * @default null
      */
     sizeNode: Node;

three/src/materials/nodes/manager/NodeMaterialObserver.d.ts

@@ -1,7 +1,9 @@
 import { BufferAttribute } from "../../../core/BufferAttribute.js";
+import { Light } from "../../../lights/Light.js";
 import { Matrix4 } from "../../../math/Matrix4.js";
 import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
 import NodeFrame from "../../../nodes/core/NodeFrame.js";
+import LightsNode from "../../../nodes/lighting/LightsNode.js";
 import Renderer from "../../../renderers/common/Renderer.js";
 import RenderObject from "../../../renderers/common/RenderObject.js";
 import { Material } from "../../Material.js";
@@ -84,6 +86,9 @@ interface RenderObjectData {
     worldMatrix: Matrix4;
     version?: number;
 }
+interface LightData {
+    map: number;
+}
 /**
  * This class is used by {@link WebGPURenderer} as management component.
  * It's primary purpose is to determine whether render objects require a
@@ -150,9 +155,25 @@ declare class NodeMaterialObserver {
      * Returns `true` if the given render object has not changed its state.
      *
      * @param {RenderObject} renderObject - The render object.
+     * @param {Array<Light>} lightsData - The current material lights.
      * @return {boolean} Whether the given render object has changed its state or not.
      */
-    equals(renderObject: RenderObject): boolean;
+    equals(renderObject: RenderObject, lightsData: Light[]): boolean;
+    /**
+     * Returns the lights data for the given material lights.
+     *
+     * @param {Array<Light>} materialLights - The material lights.
+     * @return {Array<Object>} The lights data for the given material lights.
+     */
+    getLightsData(materialLights: Light[]): LightData[];
+    /**
+     * Returns the lights for the given lights node and render ID.
+     *
+     * @param {LightsNode} lightsNode - The lights node.
+     * @param {number} renderId - The render ID.
+     * @return {Array} The lights for the given lights node and render ID.
+     */
+    getLights(lightsNode: LightsNode, renderId: number): LightData[];
     /**
      * Checks if the given render object requires a refresh.
      *

three/src/math/Frustum.d.ts

@@ -21,7 +21,7 @@ export class Frustum {
     set(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
     clone(): this;
     copy(frustum: Frustum): this;
-    setFromProjectionMatrix(m: Matrix4, coordinateSystem?: CoordinateSystem): this;
+    setFromProjectionMatrix(m: Matrix4, coordinateSystem?: CoordinateSystem, reversedDepth?: boolean): this;
     intersectsObject(object: Object3D): boolean;
     intersectsSprite(sprite: Sprite): boolean;
     intersectsSphere(sphere: Sphere): boolean;

three/src/math/Line3.d.ts

@@ -24,6 +24,7 @@ export class Line3 {
     at(t: number, target: Vector3): Vector3;
     closestPointToPointParameter(point: Vector3, clampToLine?: boolean): number;
     closestPointToPoint(point: Vector3, clampToLine: boolean, target: Vector3): Vector3;
+    distanceSqToLine3(line: Line3, c1?: Vector3, c2?: Vector3): number;
     applyMatrix4(matrix: Matrix4): Line3;
     equals(line: Line3): boolean;
 }

three/src/math/Matrix4.d.ts

@@ -246,6 +246,7 @@ export class Matrix4 {
         near: number,
         far: number,
         coordinateSystem?: CoordinateSystem,
+        reversedDepth?: boolean,
     ): this;
 
     /**
@@ -259,6 +260,7 @@ export class Matrix4 {
         near: number,
         far: number,
         coordinateSystem?: CoordinateSystem,
+        reversedDepth?: boolean,
     ): this;
 
     equals(matrix: Matrix4): boolean;

three/src/nodes/Nodes.d.ts

@@ -53,6 +53,7 @@ export { NodeUtils };
 export { default as ArrayElementNode } from "./utils/ArrayElementNode.js";
 export { default as ConvertNode } from "./utils/ConvertNode.js";
 export { default as DebugNode } from "./utils/DebugNode.js";
+export { default as EventNode } from "./utils/EventNode.js";
 export { default as FunctionOverloadingNode } from "./utils/FunctionOverloadingNode.js";
 export { default as JoinNode } from "./utils/JoinNode.js";
 export { default as LoopNode } from "./utils/LoopNode.js";

three/src/nodes/TSL.d.ts

@@ -25,6 +25,7 @@ export * from "./math/TriNoise3D.js";
 
 // utils
 export * from "./utils/EquirectUV.js";
+export * from "./utils/EventNode.js";
 export * from "./utils/FunctionOverloadingNode.js";
 export * from "./utils/LoopNode.js";
 export * from "./utils/MatcapUV.js";

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

@@ -38,6 +38,8 @@ export default class TextureNode extends UniformNode<Texture> {
 
     sample(uvNode: Node): ShaderNodeObject<Node>;
 
+    load(uvNode: Node): ShaderNodeObject<Node>;
+
     blur(amountNode: Node): ShaderNodeObject<Node>;
 
     level(levelNode: Node): ShaderNodeObject<Node>;

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

@@ -14,11 +14,17 @@ declare class ContextNode extends Node {
 export default ContextNode;
 
 export const context: (node: Node, context?: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
-export const label: (node: Node, label: string) => ShaderNodeObject<ContextNode>;
+export const setName: (node: Node, label: string) => ShaderNodeObject<ContextNode>;
+
+/**
+ * @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;
+        setName: typeof setName;
     }
 }

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

@@ -267,10 +267,17 @@ declare class Node extends EventDispatcher<{
      * @return {Node} The shared node if possible. Otherwise `this` is returned.
      */
     getShared(builder: NodeBuilder): Node;
+    /**
+     * Returns the number of elements in the node array.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {?number} The number of elements in the node array.
+     */
+    getArrayCount(builder: NodeBuilder): number | null;
     /**
      * Represents the setup stage which is the first step of the build process, see {@link Node#build} method.
-     * This method is often overwritten in derived modules to prepare the node which is used as the output/result.
-     * The output node must be returned in the `return` statement.
+     * This method is often overwritten in derived modules to prepare the node which is used as a node's output/result.
+     * If an output node is prepared, then it must be returned in the `return` statement of the derived module's setup function.
      *
      * @param {NodeBuilder} builder - The current node builder.
      * @return {?Node} The output node.

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

@@ -27,6 +27,14 @@ 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;
+    /**
+     * Sets the {@link UniformNode#name} property.
+     *
+     * @deprecated
+     * @param {string} name - The name of the uniform.
+     * @return {UniformNode} A reference to this node.
+     */
     label(name: string): this;
     /**
      * Sets the {@link UniformNode#groupNode} property.
@@ -50,6 +58,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      */
     getUniformHash(builder: NodeBuilder): string;
     onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+    getInputType(builder: NodeBuilder): string | null;
     generate(builder: NodeBuilder, output: string | null): string;
 }
 export default UniformNode;

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

@@ -1,7 +1,7 @@
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
-export default class VarNode extends Node {
+declare class VarNode extends Node {
     node: Node;
     name: string | null;
 
@@ -9,17 +9,27 @@ export default class VarNode extends Node {
 
     readOnly: boolean;
 
+    intent: boolean;
+
     constructor(node: Node, name?: string | null, readOnly?: boolean);
+
+    setIntent(value: boolean): this;
+    getIntent(): boolean;
 }
 
+export default VarNode;
+
 export const Var: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
 
 export const Const: (node: Node, name?: string | null) => ShaderNodeObject<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;
     }
 }
 

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

@@ -1,6 +1,8 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Layers } from "../../core/Layers.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Vector4 } from "../../math/Vector4.js";
+import Renderer from "../../renderers/common/Renderer.js";
 import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
@@ -61,8 +63,16 @@ declare class PassNode extends TempNode {
 
     getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
 
+    compileAsync(renderer: Renderer): Promise<void>;
+
     setSize(width: number, height: number): void;
 
+    setScissor(x: number, y: number, width: number, height: number): void;
+    setScissor(x: Vector4): void;
+
+    setViewport(x: number, y: number, width: number, height: number): void;
+    setViewport(x: Vector4): void;
+
     setPixelRatio(pixelRatio: number): void;
 
     dispose(): void;

three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -3,24 +3,32 @@ import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ComputeNode extends Node {
-    isComputeNode: true;
+    readonly isComputeNode: true;
 
-    count: number;
+    computeNode: Node;
     workgroupSize: number[];
-    dispatchCount: number;
+    count: number | null;
     name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
-    constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+    constructor(computeNode: Node, workgroupSize: number[]);
 
-    label(name: string): void;
+    setCount(count: number): this;
+    getCount(): number | null;
 
-    updateDispatchCount(): void;
+    setName(name: string): this;
+
+    /**
+     * @deprecated "label()" has been deprecated. Use "setName()" instead.
+     */
+    label(name: string): this;
 
     onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
+export const computeKernel: (node: Node, workgroupSize?: number[]) => ShaderNodeObject<ComputeNode>;
+
 export const compute: (
     node: Node,
     count: number,
@@ -30,5 +38,6 @@ export const compute: (
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         compute: typeof compute;
+        computeKernel: typeof computeKernel;
     }
 }

three/src/nodes/materialx/MaterialXNodes.d.ts

@@ -4,61 +4,96 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import { mx_hsvtorgb, mx_rgbtohsv } from "./lib/mx_hsv.js";
 import { mx_srgb_texture_to_lin_rec709 } from "./lib/mx_transform_color.js";
 
-export function mx_aastep(threshold: Node | number, value: Node | number): ShaderNodeObject<MathNode>;
+export const mx_aastep: (threshold: Node | number, value: Node | number) => ShaderNodeObject<MathNode>;
 
-export function mx_ramplr(
+export const mx_ramplr: (
     valuel: Node | number,
     valuer: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
-export function mx_ramptb(
+) => ShaderNodeObject<MathNode>;
+export const mx_ramptb: (
     valuet: Node | number,
     valueb: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
+) => ShaderNodeObject<MathNode>;
 
-export function mx_splitlr(
+export const mx_ramp4: (
+    valuetl: Node | number,
+    valuetr: Node | number,
+    valuebl: Node | number,
+    valuebr: Node | number,
+    texcoord?: Node,
+) => ShaderNodeObject<MathNode>;
+
+export const mx_splitlr: (
     valuel: Node | number,
     valuer: Node | number,
     center: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
-export function mx_splittb(
+) => ShaderNodeObject<MathNode>;
+export const mx_splittb: (
     valuet: Node | number,
     valueb: Node | number,
     center: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
+) => ShaderNodeObject<MathNode>;
 
-export function mx_transform_uv(
+export const mx_transform_uv: (
     uv_scale?: Node | number,
     uv_offset?: Node | number,
     uv_geo?: Node,
-): ShaderNodeObject<Node>;
+) => ShaderNodeObject<Node>;
 
-export function mx_safepower(in1: Node | number, in2?: Node | number): ShaderNodeObject<Node>;
+export const mx_safepower: (in1: Node | number, in2?: Node | number) => ShaderNodeObject<Node>;
 
-export function mx_contrast(
+export const mx_contrast: (
     input: Node | number,
     amount?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
+) => ShaderNodeObject<Node>;
 
-export function mx_noise_float(
+export const mx_noise_float: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
-export function mx_noise_vec3(
+) => ShaderNodeObject<Node>;
+export const mx_noise_vec3: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
-export function mx_noise_vec4(
+) => ShaderNodeObject<Node>;
+export const mx_noise_vec4: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
+) => ShaderNodeObject<Node>;
+
+export const mx_unifiednoise2d: (
+    noiseType: Node,
+    texcoord?: Node,
+    freq?: Node,
+    offset?: Node,
+    jitter?: Node | number,
+    outmin?: Node | number,
+    outmax?: Node | number,
+    clampoutput?: Node | boolean,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+) => ShaderNodeObject<Node>;
+export const mx_unifiednoise3d: (
+    noiseType: Node,
+    texcoord?: Node,
+    freq?: Node,
+    offset?: Node,
+    jitter?: Node | number,
+    outmin?: Node | number,
+    outmax?: Node | number,
+    clampoutput?: Node | boolean,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+) => ShaderNodeObject<Node>;
 
 export function mx_worley_noise_float(
     texcoord?: Node,
@@ -105,3 +140,33 @@ export function mx_fractal_noise_vec4(
 ): ShaderNodeObject<Node>;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };
+
+export const mx_add: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_subtract: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_multiply: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_divide: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_modulo: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_power: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_atan2: (in1?: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_timer: () => ShaderNodeObject<Node>;
+export const mx_frame: () => ShaderNodeObject<Node>;
+export const mx_invert: (in1: Node, amount?: Node) => ShaderNodeObject<Node>;
+export const mx_ifgreater: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
+export const mx_ifgreatereq: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
+export const mx_ifequal: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
+
+export const mx_separate: (in1: Node, channelOrOut?: string | number) => ShaderNodeObject<Node>;
+
+export const mx_place2d: (
+    texcoord: Node,
+    pivot?: Node,
+    scale?: Node,
+    rotate?: Node,
+    offset?: Node,
+) => ShaderNodeObject<Node>;
+
+export const mx_rotate2d: (input: Node, amount: Node) => ShaderNodeObject<Node>;
+
+export const mx_rotate3d: (input: Node, amount: Node, axis: Node) => ShaderNodeObject<Node>;
+
+export const mx_heighttonormal: (input: Node, scale: Node) => ShaderNodeObject<Node>;

three/src/nodes/materialx/lib/mx_noise.d.ts

@@ -357,3 +357,31 @@ export const mx_worley_noise_vec3: (
     jitter_immutable: Node | number,
     metric_immutable: Node | number,
 ) => ShaderNodeObject<Node>;
+
+export const mx_unifiednoise2d: (
+    noiseType_immutable: Node,
+    texcoord_immutable: Node,
+    freq_immutable: Node,
+    offset_immutable: Node,
+    jitter_immutable: Node,
+    outmin_immutable: Node,
+    outmax_immutable: Node,
+    clampoutput_immutable: Node,
+    octaves_immutable: Node,
+    lacunarity_immutable: Node,
+    diminish_immutable: Node,
+) => ShaderNodeObject<Node>;
+
+export const mx_unifiednoise3d: (
+    noiseType_immutable: Node,
+    position_immutable: Node,
+    freq_immutable: Node,
+    offset_immutable: Node,
+    jitter_immutable: Node,
+    outmin_immutable: Node,
+    outmax_immutable: Node,
+    clampoutput_immutable: Node,
+    octaves_immutable: Node,
+    lacunarity_immutable: Node,
+    diminish_immutable: Node,
+) => ShaderNodeObject<Node>;