@types/three 0.181.0 → 0.183.0

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 
-declare class ReferenceNode<T> extends Node {
+interface ReferenceNodeInterface<T> extends Node {
     property: string;
 
     uniformType: string;
@@ -12,17 +12,26 @@ declare class ReferenceNode<T> extends Node {
     reference: T | null;
     node: Node | null;
 
-    constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
-
     setNodeType(uniformType: string): void;
 }
 
+declare const ReferenceNode: {
+    new<TNodeType, T>(
+        property: string,
+        uniformType: TNodeType,
+        object?: T | null,
+        count?: number | null,
+    ): ReferenceNode<TNodeType, T>;
+};
+
+type ReferenceNode<TNodeType, T> = ReferenceNodeInterface<T> & Node<TNodeType>;
+
 export default ReferenceNode;
 
-export const reference: <T>(name: string, type: string, object: T) => ReferenceNode<T>;
-export const referenceBuffer: <T>(
+export const reference: <const TNodeType, T>(name: string, type: TNodeType, object: T) => ReferenceNode<TNodeType, T>;
+export const referenceBuffer: <const TNodeType, T>(
     name: string,
-    type: string,
+    type: TNodeType,
     count: number,
     object: T,
-) => ReferenceNode<T>;
+) => ReferenceNode<TNodeType, T>;

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

@@ -1,8 +1,7 @@
 import Node from "../core/Node.js";
-import VarNode from "../core/VarNode.js";
 
-export const reflectView: Node;
-export const refractView: Node;
+export const reflectView: Node<"vec3">;
+export const refractView: Node<"vec3">;
 
-export const reflectVector: VarNode;
-export const refractVector: VarNode;
+export const reflectVector: Node<"vec3">;
+export const refractVector: Node<"vec3">;

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

@@ -1,7 +1,7 @@
 import Renderer from "../../renderers/common/Renderer.js";
 import ReferenceNode from "./ReferenceNode.js";
 
-export default class RendererReferenceNode extends ReferenceNode<Renderer> {
+export default class RendererReferenceNode extends ReferenceNode<unknown, Renderer> {
     renderer: Renderer | null;
 
     constructor(property: string, inputType: string, renderer?: Renderer | null);

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

@@ -0,0 +1,5 @@
+import Node from "../core/Node.js";
+
+export const backgroundBlurriness: Node<"float">;
+export const backgroundIntensity: Node<"float">;
+export const backgroundRotation: Node<"mat4">;

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

@@ -19,11 +19,13 @@ export default class SkinningNode extends Node {
 
     getSkinnedPosition(boneMatrices?: Node, position?: Node): Node;
 
-    getSkinnedNormal(boneMatrices?: Node, normal?: Node): Node;
+    getSkinnedNormalAndTangent(
+        boneMatrices?: Node,
+        normal?: Node,
+        tangent?: Node,
+    ): { skinNormal: Node; skinTangent: Node };
 
     getPreviousSkinnedPosition(builder: NodeBuilder): Node;
-
-    needsPreviousBoneMatrices(builder: NodeBuilder): boolean;
 }
 
 export const skinning: (skinnedMesh: SkinnedMesh) => SkinningNode;

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

@@ -8,7 +8,7 @@ import StructTypeNode from "../core/StructTypeNode.js";
 import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
-export default class StorageBufferNode extends BufferNode<StorageBufferAttribute | StorageInstancedBufferAttribute> {
+interface StorageBufferNodeInterface<TNodeType> {
     readonly isStorageBufferNode: true;
 
     structTypeNode: StructTypeNode | null;
@@ -19,13 +19,7 @@ export default class StorageBufferNode extends BufferNode<StorageBufferAttribute
 
     bufferObject: boolean;
 
-    constructor(
-        value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-        bufferType?: string | Struct | null,
-        bufferCount?: number,
-    );
-
-    element: (indexNode: Node | number) => StorageArrayElementNode;
+    element: (indexNode: Node | number) => StorageArrayElementNode<TNodeType>;
 
     setPBO(value: boolean): this;
 
@@ -39,18 +33,51 @@ export default class StorageBufferNode extends BufferNode<StorageBufferAttribute
 
     toAtomic(): this;
 }
+declare const StorageBufferNode: {
+    new<TNodeType>(
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute,
+        bufferType?: string | Struct | null,
+        bufferCount?: number,
+    ): StorageBufferNode<TNodeType>;
+};
+
+type StorageBufferNode<TNodeType> =
+    & StorageBufferNodeInterface<TNodeType>
+    & BufferNode<TNodeType, StorageBufferAttribute | StorageInstancedBufferAttribute>;
+
+export default StorageBufferNode;
+
+interface Storage {
+    (
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
+        type: "float",
+        count: number,
+    ): StorageBufferNode<"float">;
+    (
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
+        type: "uint",
+        count: number,
+    ): StorageBufferNode<"uint">;
+    (
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
+        type: "vec2",
+        count: number,
+    ): StorageBufferNode<"vec2">;
+    (
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
+        type: "vec3",
+        count: number,
+    ): StorageBufferNode<"vec3">;
+    (
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
+        type: "vec4",
+        count: number,
+    ): StorageBufferNode<"vec4">;
+    (
+        value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
+        type: Struct,
+        count: number,
+    ): StorageBufferNode<"struct">;
+}
 
-export const storage: (
-    value: StorageBufferAttribute | StorageInstancedBufferAttribute | BufferAttribute,
-    type?: string | Struct | null,
-    count?: number,
-) => StorageBufferNode;
-
-/**
- * @deprecated
- */
-export const storageObject: (
-    value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    type?: string | Struct | null,
-    count?: number,
-) => StorageBufferNode;
+export const storage: Storage;

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

@@ -39,7 +39,7 @@ export const storageTexture: (
 ) => StorageTextureNode;
 
 export const textureStore: (
-    value: Texture,
+    value: Texture | StorageTextureNode,
     uvNode?: Node | null,
     storeNode?: Node,
 ) => StorageTextureNode;

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

@@ -1,8 +1,6 @@
-import AttributeNode from "../core/AttributeNode.js";
-import VaryingNode from "../core/VaryingNode.js";
-import MathNode from "../math/MathNode.js";
+import Node from "../core/Node.js";
 
-export const tangentGeometry: AttributeNode;
-export const tangentLocal: VaryingNode;
-export const tangentView: MathNode;
-export const tangentWorld: MathNode;
+export const tangentGeometry: Node<"vec4">;
+export const tangentLocal: Node<"vec3">;
+export const tangentView: Node<"vec3">;
+export const tangentWorld: Node<"vec3">;

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

@@ -7,7 +7,7 @@ export default class Texture3DNode extends TextureNode {
 
     constructor(value: Texture, uvNode?: Node | null, levelNode?: Node | null);
 
-    normal(uvNode: Node): Node;
+    normal(uvNode: Node): Node<"vec3">;
 }
 
 export const texture3D: (
@@ -15,3 +15,15 @@ export const texture3D: (
     uvNode?: Node | null,
     levelNode?: Node | number | null,
 ) => Texture3DNode;
+
+export const texture3DLoad: (
+    value: Texture,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
+) => Texture3DNode;
+
+export const texture3DLevel: (
+    value: Texture,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
+) => Texture3DNode;

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

@@ -1,5 +1,6 @@
 import Node from "../core/Node.js";
+import TextureNode from "./TextureNode.js";
 
-export const textureBicubicLevel: (textureNode: Node, lodNode: Node) => Node;
+export const textureBicubicLevel: (textureNode: Node, lodNode: Node) => TextureNode;
 
-export const textureBicubic: (textureNode: Node, strength: Node) => Node;
+export const textureBicubic: (textureNode: Node, strength: Node) => TextureNode;

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

@@ -2,10 +2,10 @@ import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
 
-export default class TextureNode extends UniformNode<Texture> {
+interface TextureNodeInterface<TNodeType> {
     readonly isTextureNode: true;
 
-    uvNode: Node | null;
+    uvNode: Node<"vec2"> | Node<"vec3"> | null;
     levelNode: Node | null;
     biasNode: Node | null;
     compareNode: Node | null;
@@ -17,27 +17,15 @@ export default class TextureNode extends UniformNode<Texture> {
 
     referenceNode: Node | null;
 
-    constructor(
-        value?: Texture,
-        uvNode?: Node | null,
-        levelNode?: Node | null,
-        biasNode?: Node | null,
-    );
-
     getDefaultUV(): Node;
 
     setSampler(value: boolean): this;
 
     getSampler(): boolean;
 
-    /**
-     * @deprecated
-     */
-    uv(uvNode: Node): Node;
-
-    sample(uvNode: Node): Node;
+    sample(uvNode: Node): Node<TNodeType>;
 
-    load(uvNode: Node): Node;
+    load(uvNode: Node): Node<TNodeType>;
 
     blur(amountNode: Node): Node;
 
@@ -51,13 +39,26 @@ export default class TextureNode extends UniformNode<Texture> {
 
     compare(compareNode: Node): Node;
 
-    grad(gradeNodeX: Node, gradeNodeY: Node): Node;
+    grad(gradeNodeX: Node, gradeNodeY: Node): TextureNode;
 
-    depth(depthNode: Node): Node;
+    depth(depthNode: Node): TextureNode;
 
     clone(): this;
 }
 
+declare const TextureNode: {
+    new(
+        value?: Texture,
+        uvNode?: Node | null,
+        levelNode?: Node | null,
+        biasNode?: Node | null,
+    ): TextureNode;
+};
+
+type TextureNode<TNodeType = "vec4"> = TextureNodeInterface<TNodeType> & UniformNode<TNodeType, Texture>;
+
+export default TextureNode;
+
 export const texture: (
     value?: Texture | TextureNode,
     uvNode?: Node | null,

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

@@ -1,3 +1,3 @@
 import AttributeNode from "../core/AttributeNode.js";
 
-export const uv: (index?: number) => AttributeNode;
+export const uv: (index?: number) => AttributeNode<"vec2">;

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

@@ -2,24 +2,26 @@ import Node from "../core/Node.js";
 import ArrayElementNode from "../utils/ArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
-declare class UniformArrayElementNode extends ArrayElementNode {
-    constructor(arrayBuffer: Node, indexNode: Node);
-}
+type UniformArrayElementNode<TNodeType> = ArrayElementNode<TNodeType>;
 
-declare class UniformArrayNode extends BufferNode<unknown[]> {
+interface UniformArrayNodeInterface<TNodeType> {
     array: unknown[];
     elementType: string | null;
     paddedType: string;
 
     readonly isArrayBufferNode: true;
 
-    constructor(value: unknown[], elementType?: string | null);
-
     getPaddedType(): string;
 
-    element: (indexNode: Node) => UniformArrayElementNode;
+    element: (indexNode: Node | number) => UniformArrayElementNode<TNodeType>;
 }
 
+declare const UniformArrayNode: {
+    new<TNodeType>(value: unknown[], elementType?: TNodeType | null): UniformArrayNode<TNodeType>;
+};
+
+type UniformArrayNode<TNodeType> = UniformArrayNodeInterface<TNodeType> & BufferNode<TNodeType, unknown[]>;
+
 export default UniformArrayNode;
 
-export const uniformArray: (values: unknown[], nodeType?: string | null) => UniformArrayNode;
+export const uniformArray: <TNodeType>(values: unknown[], nodeType?: TNodeType | null) => UniformArrayNode<TNodeType>;

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

@@ -2,7 +2,7 @@ import ReferenceNode from "./ReferenceNode.js";
 
 export type NodeUserData = Record<string, any>;
 
-export default class UserDataNode extends ReferenceNode<NodeUserData> {
+export default class UserDataNode extends ReferenceNode<unknown, NodeUserData> {
     userData: NodeUserData | null;
     constructor(property: string, inputType: string, userData?: NodeUserData | null);
 }

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

@@ -5,9 +5,9 @@ import UniformNode from "../core/UniformNode.js";
 declare class VelocityNode extends TempNode {
     projectionMatrix: Matrix4 | null;
 
-    previousModelWorldMatrix: UniformNode<Matrix4>;
-    previousProjectionMatrix: UniformNode<Matrix4>;
-    previousCameraViewMatrix: UniformNode<Matrix4>;
+    previousModelWorldMatrix: UniformNode<"mat4", Matrix4>;
+    previousProjectionMatrix: UniformNode<"mat4", Matrix4>;
+    previousCameraViewMatrix: UniformNode<"mat4", Matrix4>;
 
     constructor();
 

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

@@ -1,6 +1,6 @@
 import AttributeNode from "../core/AttributeNode.js";
 
-export default class VertexColorNode extends AttributeNode {
+export default class VertexColorNode extends AttributeNode<"vec4"> {
     readonly isVertexColorNode: true;
 
     index: number;

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

@@ -23,6 +23,5 @@ export const call: <P extends FunctionNodeArguments>(
 declare module "../Nodes.js" {
     interface FunctionNode<P extends FunctionNodeArguments> {
         call: (parameters?: ProxiedObject<P>) => FunctionCallNode<P>;
-        callAssign: (parameters?: ProxiedObject<P>) => this;
     }
 }

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

@@ -14,23 +14,27 @@ export default class FunctionNode<P extends Array<Node | number> | { [name: stri
     getNodeFunction(builder: NodeBuilder): NodeFunction;
 }
 
+// eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
 type FnParameters<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
+    // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
     : readonly [ProxiedObject<P>];
 
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 export const nativeFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     language?: string,
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 ) => (...params: FnParameters<P>) => Node;
 
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 export const glslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 ) => (...params: FnParameters<P>) => Node;
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 export const wgslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
 ) => (...params: FnParameters<P>) => Node;
+
+export {};

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

@@ -18,9 +18,8 @@ interface ArrayFunction {
 
 export const array: ArrayFunction;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "./Node.js" {
+    interface NodeElements {
         toArray: (count: number) => ArrayNode;
-        toArrayAssign: (count: number) => this;
     }
 }

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

@@ -1,15 +1,21 @@
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
-export default class AttributeNode extends Node {
-    constructor(attributeName: string, nodeType?: string | null);
-
+interface AttributeNodeInterface {
     setAttributeName(attributeName: string): this;
 
     getAttributeName(builder: NodeBuilder): string;
 }
 
-export const attribute: (
+declare const AttributeNode: {
+    new<TNodeType>(attributeName: string, TNodeType?: string | null): AttributeNode<TNodeType>;
+};
+
+type AttributeNode<TNodeType = unknown> = Node<TNodeType> & AttributeNodeInterface;
+
+export default AttributeNode;
+
+export const attribute: <TNodeType>(
     name: string,
-    nodeType?: string | null,
-) => AttributeNode;
+    nodeType?: TNodeType | null,
+) => AttributeNode<TNodeType>;

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

@@ -10,9 +10,8 @@ export default class BypassNode extends Node {
 
 export const bypass: (returnNode: Node, callNode: Node) => BypassNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "./Node.js" {
+    interface NodeElements {
         bypass: (callNode: Node) => BypassNode;
-        bypassAssign: (callNode: Node) => this;
     }
 }

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

@@ -1,9 +1,16 @@
 import InputNode from "./InputNode.js";
 import NodeBuilder from "./NodeBuilder.js";
 
-export default class ConstNode<Value> extends InputNode<Value> {
-    isConstNode: true;
-    constructor(value: Value, nodeType?: string | null);
+interface ConstNodeInterface {
+    readonly isConstNode: true;
 
     generateConst(builder: NodeBuilder): string;
 }
+
+declare const ConstNode: {
+    new<TNodeType, TValue>(value: TValue, nodeType?: TNodeType | null): ConstNode<TNodeType, TValue>;
+};
+
+type ConstNode<TNodeType, TValue> = InputNode<TNodeType, TValue> & ConstNodeInterface;
+
+export default ConstNode;

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

@@ -1,46 +1,57 @@
+import { Light } from "../../lights/Light.js";
 import Node from "./Node.js";
 import { NodeBuilderContext } from "./NodeBuilder.js";
 
-declare class ContextNode extends Node {
+declare class ContextNodeInterface<TNodeType> extends Node {
     readonly isContextNode: true;
 
-    node: Node;
+    node: Node<TNodeType> | null;
     value: NodeBuilderContext;
-
-    constructor(node: Node, value?: NodeBuilderContext);
 }
 
+declare const ContextNode: {
+    new<TNodeType>(node?: Node<TNodeType> | null, value?: NodeBuilderContext): ContextNode<TNodeType>;
+};
+
+type ContextNode<TNodeType> = ContextNodeInterface<TNodeType> & Node<TNodeType>;
+
 export default ContextNode;
 
-export const context: (node: Node, context?: NodeBuilderContext) => ContextNode;
+interface ContextFunction {
+    (value?: NodeBuilderContext): ContextNode<unknown>;
+    <TNodeType>(node: Node<TNodeType>, value?: NodeBuilderContext): ContextNode<TNodeType>;
+}
+
+export const context: ContextFunction;
+
+export const uniformFlow: <TNodeType>(node: Node<TNodeType>) => ContextNode<TNodeType>;
 
-export const uniformFlow: (node: Node) => ContextNode;
+export const setName: <TNodeType>(node: Node<TNodeType>, label: string) => Node<TNodeType>;
 
-export const setName: (node: Node, label: string) => Node;
+export function builtinShadowContext(shadowNode: Node, light: Light, node?: Node | null): ContextNode<unknown>;
+
+export function builtinAOContext(aoNode: Node, node?: Node | null): ContextNode<unknown>;
 
 /**
  * @deprecated "label()" has been deprecated. Use "setName()" instead.
  */
-export function label(node: Node, label: string): Node;
+export function label<TNodeType>(node: Node<TNodeType>, label: string): Node<TNodeType>;
 
-declare module "../Nodes.js" {
-    interface Node {
-        context: (context?: NodeBuilderContext) => ContextNode;
-        contextAssign: (context?: NodeBuilderContext) => this;
+declare module "./Node.js" {
+    interface NodeExtensions<TNodeType> {
+        context: (context?: NodeBuilderContext) => ContextNode<TNodeType>;
 
         /**
          * @deprecated "label()" has been deprecated. Use "setName()" instead.
          */
-        label: (label: string) => Node;
-        /**
-         * @deprecated "label()" has been deprecated. Use "setName()" instead.
-         */
-        labelAssign: (label: string) => this;
+        label: (label: string) => Node<TNodeType>;
+
+        uniformFlow: () => ContextNode<TNodeType>;
+
+        setName: (label: string) => Node<TNodeType>;
 
-        uniformFlow: () => ContextNode;
-        uniformFlowAssign: () => this;
+        builtinShadowContext: (shadowNode: Node, light: Light) => ContextNode<TNodeType>;
 
-        setName: (label: string) => Node;
-        setNameAssign: (label: string) => this;
+        builtinAOContext: (aoValue: Node) => ContextNode<TNodeType>;
     }
 }

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

@@ -8,7 +8,7 @@ export type IndexNodeScope =
     | typeof IndexNode.INVOCATION_SUBGROUP
     | typeof IndexNode.DRAW;
 
-declare class IndexNode extends Node {
+declare class IndexNode extends Node<"uint"> {
     scope: IndexNodeScope;
 
     readonly isInstanceNode: true;

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

@@ -3,13 +3,21 @@ import NodeBuilder from "./NodeBuilder.js";
 
 export type Precision = "low" | "medium" | "high";
 
-export default abstract class InputNode<Value> extends Node {
+interface InputNodeInterface<TValue> {
     isInputNode: true;
-    value: Value;
+    value: TValue;
     precision: Precision | null;
 
-    constructor(value: Value, nodeType?: string | null);
-
     getInputType(builder: NodeBuilder): string | null;
     setPrecision(precision: Precision): this;
 }
+
+declare const InputNode: {
+    new<TNodeType, TValue>(value: TValue, nodeType?: TNodeType | null): InputNode<TNodeType, TValue>;
+};
+
+type InputNode<TNodeType, TValue> = Node<TNodeType> & InputNodeInterface<TValue>;
+
+export default InputNode;
+
+export type { InputNode };

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

@@ -8,9 +8,8 @@ export default InspectorNode;
 
 export function inspector<T extends Node>(node: T, name?: string, callback?: (node: T) => Node): T;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "./Node.js" {
+    interface NodeElements {
         toInspector: (name?: string, callback?: (node: this) => Node) => this;
-        toInspectorAssign: (name?: string, callback?: (node: this) => Node) => this;
     }
 }

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

@@ -19,18 +19,13 @@ export const isolate: (node: Node) => IsolateNode;
  */
 export const cache: (node: Node, cache?: NodeCache) => IsolateNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "./Node.js" {
+    interface NodeElements {
         /**
          * @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;
     }
 }