@types/three 0.160.0 → 0.161.1

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -1,6 +1,6 @@
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type MathNodeMethod1 =
     | typeof MathNode.RADIANS
@@ -59,58 +59,58 @@ export type MathNodeMethod = MathNodeMethod1 | MathNodeMethod2 | MathNodeMethod3
 export default class MathNode extends TempNode {
     // 1 input
 
-    static RADIANS: 'radians';
-    static DEGREES: 'degrees';
-    static EXP: 'exp';
-    static EXP2: 'exp2';
-    static LOG: 'log';
-    static LOG2: 'log2';
-    static SQRT: 'sqrt';
-    static INVERSE_SQRT: 'inversesqrt';
-    static FLOOR: 'floor';
-    static CEIL: 'ceil';
-    static NORMALIZE: 'normalize';
-    static FRACT: 'fract';
-    static SIN: 'sin';
-    static COS: 'cos';
-    static TAN: 'tan';
-    static ASIN: 'asin';
-    static ACOS: 'acos';
-    static ATAN: 'atan';
-    static ABS: 'abs';
-    static SIGN: 'sign';
-    static LENGTH: 'length';
-    static NEGATE: 'negate';
-    static ONE_MINUS: 'oneMinus';
-    static DFDX: 'dFdx';
-    static DFDY: 'dFdy';
-    static ROUND: 'round';
-    static RECIPROCAL: 'reciprocal';
-    static TRUNC: 'trunc';
-    static FWIDTH: 'fwidth';
-    static BITCAST: 'bitcast';
+    static RADIANS: "radians";
+    static DEGREES: "degrees";
+    static EXP: "exp";
+    static EXP2: "exp2";
+    static LOG: "log";
+    static LOG2: "log2";
+    static SQRT: "sqrt";
+    static INVERSE_SQRT: "inversesqrt";
+    static FLOOR: "floor";
+    static CEIL: "ceil";
+    static NORMALIZE: "normalize";
+    static FRACT: "fract";
+    static SIN: "sin";
+    static COS: "cos";
+    static TAN: "tan";
+    static ASIN: "asin";
+    static ACOS: "acos";
+    static ATAN: "atan";
+    static ABS: "abs";
+    static SIGN: "sign";
+    static LENGTH: "length";
+    static NEGATE: "negate";
+    static ONE_MINUS: "oneMinus";
+    static DFDX: "dFdx";
+    static DFDY: "dFdy";
+    static ROUND: "round";
+    static RECIPROCAL: "reciprocal";
+    static TRUNC: "trunc";
+    static FWIDTH: "fwidth";
+    static BITCAST: "bitcast";
 
     // 2 inputs
 
-    static ATAN2: 'atan2';
-    static MIN: 'min';
-    static MAX: 'max';
-    static MOD: 'mod';
-    static STEP: 'step';
-    static REFLECT: 'reflect';
-    static DISTANCE: 'distance';
-    static DOT: 'dot';
-    static CROSS: 'cross';
-    static POW: 'pow';
-    static TRANSFORM_DIRECTION: 'transformDirection';
+    static ATAN2: "atan2";
+    static MIN: "min";
+    static MAX: "max";
+    static MOD: "mod";
+    static STEP: "step";
+    static REFLECT: "reflect";
+    static DISTANCE: "distance";
+    static DOT: "dot";
+    static CROSS: "cross";
+    static POW: "pow";
+    static TRANSFORM_DIRECTION: "transformDirection";
 
     // 3 inputs
 
-    static MIX: 'mix';
-    static CLAMP: 'clamp';
-    static REFRACT: 'refract';
-    static SMOOTHSTEP: 'smoothstep';
-    static FACEFORWARD: 'faceforward';
+    static MIX: "mix";
+    static CLAMP: "clamp";
+    static REFRACT: "refract";
+    static SMOOTHSTEP: "smoothstep";
+    static FACEFORWARD: "faceforward";
 
     method: MathNodeMethod;
     aNode: Node;
@@ -124,8 +124,10 @@ export default class MathNode extends TempNode {
 
 export const EPSILON: ShaderNodeObject<Node>;
 export const INFINITY: ShaderNodeObject<Node>;
+export const PI: ShaderNodeObject<Node>;
+export const PI2: ShaderNodeObject<Node>;
 
-export type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
+type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const radians: Unary;
 export const degrees: Unary;
@@ -158,7 +160,7 @@ export const trunc: Unary;
 export const fwidth: Unary;
 export const bitcast: Unary;
 
-export type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
 export const atan2: Binary;
 export const min: Binary;
@@ -176,15 +178,17 @@ export const pow3: Binary;
 export const pow4: Binary;
 export const transformDirection: Binary;
 
-export type Ternary = (
-    a: NodeRepresentation,
-    b: NodeRepresentation,
-    c: NodeRepresentation,
-) => ShaderNodeObject<MathNode>;
+type Ternary = (a: NodeRepresentation, b: NodeRepresentation, c: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
+export const cbrt: Unary;
+export const lengthSq: Unary;
 export const mix: Ternary;
-export const clamp: Ternary;
-export const saturate: Ternary;
+export const clamp: (
+    a: NodeRepresentation,
+    b?: NodeRepresentation,
+    c?: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+export const saturate: Unary;
 export const refract: Ternary;
 export const smoothstep: Ternary;
 export const faceForward: Ternary;
@@ -192,7 +196,7 @@ export const faceForward: Ternary;
 export const mixElement: Ternary;
 export const smoothstepElement: Ternary;
 
-declare module '../shadernode/ShaderNode.js' {
+declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {
         radians: typeof radians;
         degrees: typeof degrees;
@@ -215,6 +219,7 @@ declare module '../shadernode/ShaderNode.js' {
         abs: typeof abs;
         sign: typeof sign;
         length: typeof length;
+        lengthSq: typeof lengthSq;
         negate: typeof negate;
         oneMinus: typeof oneMinus;
         dFdx: typeof dFdx;
@@ -244,5 +249,6 @@ declare module '../shadernode/ShaderNode.js' {
         faceForward: typeof faceForward;
         difference: typeof difference;
         saturate: typeof saturate;
+        cbrt: typeof cbrt;
     }
 }

three/examples/jsm/nodes/math/MathUtils.d.ts

@@ -0,0 +1,16 @@
+import { Binary, Ternary } from "./MathNode.js";
+
+// remapping functions
+export const parabola: Binary;
+export const gain: Binary;
+export const pcurve: Ternary;
+export const sinc: Binary;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        parabola: typeof parabola;
+        gain: typeof gain;
+        pcurve: typeof pcurve;
+        sinc: typeof sinc;
+    }
+}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -1,27 +1,26 @@
-import TempNode from '../core/TempNode.js';
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type OperatorNodeOp =
-    | '='
-    | '%'
-    | '&'
-    | '|'
-    | '^'
-    | '>>'
-    | '<<'
-    | '=='
-    | '&&'
-    | '||'
-    | '^^'
-    | '<'
-    | '>'
-    | '<='
-    | '>='
-    | '+'
-    | '-'
-    | '*'
-    | '/';
+    | "%"
+    | "&"
+    | "|"
+    | "^"
+    | ">>"
+    | "<<"
+    | "=="
+    | "&&"
+    | "||"
+    | "^^"
+    | "<"
+    | ">"
+    | "<="
+    | ">="
+    | "+"
+    | "-"
+    | "*"
+    | "/";
 
 export default class OperatorNode extends TempNode {
     aNode: Node;
@@ -31,7 +30,7 @@ export default class OperatorNode extends TempNode {
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 
-export type Operator = (
+type Operator = (
     a: NodeRepresentation,
     b: NodeRepresentation,
     ...others: NodeRepresentation[]
@@ -43,21 +42,22 @@ export const mul: Operator;
 export const div: Operator;
 export const remainder: Operator;
 export const equal: Operator;
-export const assign: Operator;
 export const lessThan: Operator;
 export const greaterThan: Operator;
 export const lessThanEqual: Operator;
 export const greaterThanEqual: Operator;
 export const and: Operator;
 export const or: Operator;
+export const not: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 export const xor: Operator;
 export const bitAnd: Operator;
+export const bitNot: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 export const bitOr: Operator;
 export const bitXor: Operator;
 export const shiftLeft: Operator;
 export const shiftRight: Operator;
 
-declare module '../shadernode/ShaderNode.js' {
+declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {
         add: typeof add;
         sub: typeof sub;
@@ -65,15 +65,16 @@ declare module '../shadernode/ShaderNode.js' {
         div: typeof div;
         remainder: typeof remainder;
         equal: typeof equal;
-        assign: typeof assign;
         lessThan: typeof lessThan;
         greaterThan: typeof greaterThan;
         lessThanEqual: typeof lessThanEqual;
         greaterThanEqual: typeof greaterThanEqual;
         and: typeof and;
         or: typeof or;
+        not: typeof not;
         xor: typeof xor;
         bitAnd: typeof bitAnd;
+        bitNot: typeof bitNot;
         bitOr: typeof bitOr;
         bitXor: typeof bitXor;
         shiftLeft: typeof shiftLeft;

three/examples/jsm/nodes/math/TriNoise3D.d.ts

@@ -0,0 +1,12 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export const tri: (x: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const tri3: (p: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const triNoise3D: (
+    p_immutable: NodeRepresentation,
+    spd: NodeRepresentation,
+    time: NodeRepresentation,
+) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -1,5 +1,5 @@
-import TempNode from '../core/TempNode.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class CheckerNode extends TempNode {
     uvNode: Node;
@@ -7,3 +7,9 @@ export default class CheckerNode extends TempNode {
 }
 
 export const checker: (uvNode?: NodeRepresentation) => ShaderNodeObject<CheckerNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        checker: typeof checker;
+    }
+}

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -1,22 +1,63 @@
-import Node from '../core/Node.js';
-import { NodeTypeOption, SwizzleOption } from '../core/constants.js';
-import ConstNode from '../core/ConstNode.js';
-import NodeBuilder from '../core/NodeBuilder.js';
-import SplitNode from '../utils/SplitNode.js';
-
-export interface NodeElements {}
+import { AnyObject, NodeTypeOption, SwizzleOption } from "../core/constants.js";
+import ConstNode from "../core/ConstNode.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+
+export interface NodeElements {
+    append: typeof append;
+
+    color: typeof color;
+    float: typeof float;
+    int: typeof int;
+    uint: typeof uint;
+    bool: typeof bool;
+    vec2: typeof vec2;
+    ivec2: typeof ivec2;
+    uvec2: typeof uvec2;
+    bvec2: typeof bvec2;
+    vec3: typeof vec3;
+    ivec3: typeof ivec3;
+    uvec3: typeof uvec3;
+    bvec3: typeof bvec3;
+    vec4: typeof vec4;
+    ivec4: typeof ivec4;
+    uvec4: typeof uvec4;
+    bvec4: typeof bvec4;
+    mat2: typeof mat2;
+    imat2: typeof imat2;
+    umat2: typeof umat2;
+    bmat2: typeof bmat2;
+    mat3: typeof mat3;
+    imat3: typeof imat3;
+    umat3: typeof umat3;
+    bmat3: typeof bmat3;
+    mat4: typeof mat4;
+    imat4: typeof imat4;
+    umat4: typeof umat4;
+    bmat4: typeof bmat4;
+    string: typeof string;
+    arrayBuffer: typeof arrayBuffer;
+
+    element: typeof element;
+    convert: typeof convert;
+}
 
 export function addNodeElement(name: string, nodeElement: unknown): void;
 
-export type Swizzable<T extends Node = Node> = T & {
-    [key in SwizzleOption | number]: ShaderNodeObject<SplitNode>;
-};
-
-export type ShaderNodeObject<T extends Node> = T & {
-    [Key in keyof NodeElements]: NodeElements[Key] extends (node: T, ...args: infer Args) => infer R
-        ? (...args: Args) => R
-        : never;
-} & Swizzable<T>;
+export type Swizzable<T extends Node = Node> =
+    & T
+    & {
+        [key in SwizzleOption | number]: ShaderNodeObject<Node>;
+    };
+
+export type ShaderNodeObject<T extends Node> =
+    & T
+    & {
+        [Key in keyof NodeElements]: NodeElements[Key] extends (node: T, ...args: infer Args) => infer R
+            ? (...args: Args) => R
+            : never;
+    }
+    & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
 export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
@@ -25,10 +66,8 @@ export type NodeRepresentation<T extends Node = Node> = number | boolean | Node
 export type NodeObjectOption = NodeRepresentation | string;
 
 // same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
-export type NodeObject<T> = T extends Node
-    ? ShaderNodeObject<T>
-    : T extends number | boolean
-    ? ShaderNodeObject<ConstNode<number | boolean>>
+export type NodeObject<T> = T extends Node ? ShaderNodeObject<T>
+    : T extends number | boolean ? ShaderNodeObject<ConstNode<number | boolean>>
     : T;
 
 // opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
@@ -63,25 +102,21 @@ interface Construtors<
  * <https://stackoverflow.com/a/52761156/1623826>
  */
 type OverloadedConstructorsOf<T> = T extends {
-    new (...args: infer A1): unknown;
-    new (...args: infer A2): unknown;
-    new (...args: infer A3): unknown;
-    new (...args: infer A4): unknown;
-}
-    ? Construtors<A1, A2, A3, A4>
+    new(...args: infer A1): unknown;
+    new(...args: infer A2): unknown;
+    new(...args: infer A3): unknown;
+    new(...args: infer A4): unknown;
+} ? Construtors<A1, A2, A3, A4>
     : T extends {
-          new (...args: infer A1): unknown;
-          new (...args: infer A2): unknown;
-          new (...args: infer A3): unknown;
-      }
-    ? Construtors<A1, A2, A3, undefined>
+        new(...args: infer A1): unknown;
+        new(...args: infer A2): unknown;
+        new(...args: infer A3): unknown;
+    } ? Construtors<A1, A2, A3, undefined>
     : T extends {
-          new (...args: infer A1): unknown;
-          new (...args: infer A2): unknown;
-      }
-    ? Construtors<A1, A2, undefined, undefined>
-    : T extends new (...args: infer A) => unknown
-    ? Construtors<A, undefined, undefined, undefined>
+        new(...args: infer A1): unknown;
+        new(...args: infer A2): unknown;
+    } ? Construtors<A1, A2, undefined, undefined>
+    : T extends new(...args: infer A) => unknown ? Construtors<A, undefined, undefined, undefined>
     : Construtors<undefined, undefined, undefined, undefined>;
 
 type AnyConstructors = Construtors<any, any, any, any>;
@@ -91,29 +126,29 @@ type AnyConstructors = Construtors<any, any, any, any>;
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 type FilterConstructorsByScope<T extends AnyConstructors, S> = {
-    a: S extends T['a'][0] ? T['a'] : undefined;
-    b: S extends T['b'][0] ? T['b'] : undefined;
-    c: S extends T['c'][0] ? T['c'] : undefined;
-    d: S extends T['d'][0] ? T['d'] : undefined;
+    a: S extends T["a"][0] ? T["a"] : undefined;
+    b: S extends T["b"][0] ? T["b"] : undefined;
+    c: S extends T["c"][0] ? T["c"] : undefined;
+    d: S extends T["d"][0] ? T["d"] : undefined;
 };
 /**
  * "flattens" the tuple into an union type
  */
 type ConstructorUnion<T extends AnyConstructors> =
-    | Exclude<T['a'], undefined>
-    | Exclude<T['b'], undefined>
-    | Exclude<T['c'], undefined>
-    | Exclude<T['d'], undefined>;
+    | Exclude<T["a"], undefined>
+    | Exclude<T["b"], undefined>
+    | Exclude<T["c"], undefined>
+    | Exclude<T["d"], undefined>;
 
 /**
  * Extract list of possible scopes - union of the first paramter
  * of all constructors, should it be string
  */
 type ExtractScopes<T extends AnyConstructors> =
-    | (T['a'][0] extends string ? T['a'][0] : never)
-    | (T['b'][0] extends string ? T['b'][0] : never)
-    | (T['c'][0] extends string ? T['c'][0] : never)
-    | (T['d'][0] extends string ? T['d'][0] : never);
+    | (T["a"][0] extends string ? T["a"][0] : never)
+    | (T["b"][0] extends string ? T["b"][0] : never)
+    | (T["c"][0] extends string ? T["c"][0] : never)
+    | (T["d"][0] extends string ? T["d"][0] : never);
 
 type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
 type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
@@ -123,7 +158,7 @@ export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
 
 type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
 type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
-type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends Node ? R : never) : never;
+type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends Node ? R : never) : never;
 
 export type NodeOrType = Node | NodeTypeOption;
 
@@ -162,6 +197,13 @@ export function nodeImmutable<T>(
     ...params: ProxiedTuple<GetConstructors<T>>
 ): ShaderNodeObject<ConstructedNode<T>>;
 
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+export function tslFn<T extends AnyObject, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: T) => R;
+
+export function append(node: Node): Node;
+
 export const color: ConvertType;
 
 export const float: ConvertType;
@@ -184,6 +226,11 @@ export const ivec4: ConvertType;
 export const uvec4: ConvertType;
 export const bvec4: ConvertType;
 
+export const mat2: ConvertType;
+export const imat2: ConvertType;
+export const umat2: ConvertType;
+export const bmat2: ConvertType;
+
 export const mat3: ConvertType;
 export const imat3: ConvertType;
 export const umat3: ConvertType;
@@ -194,5 +241,8 @@ export const imat4: ConvertType;
 export const umat4: ConvertType;
 export const bmat4: ConvertType;
 
+export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
+export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
+
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
 export const convert: (node: NodeRepresentation, types: NodeTypeOption) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/utils/ArrayElementNode.d.ts

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { TempNode } from '../Nodes.js';
+import Node from "../core/Node.js";
+import { TempNode } from "../Nodes.js";
 
 export default class ArrayElementNode extends TempNode {
     node: Node;

three/examples/jsm/nodes/utils/ConvertNode.d.ts

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { NodeTypeOption } from '../Nodes.js';
+import Node from "../core/Node.js";
+import { NodeTypeOption } from "../Nodes.js";
 
 export default class ConvertNode extends Node {
     node: Node;

three/examples/jsm/nodes/utils/DiscardNode.d.ts

@@ -0,0 +1,16 @@
+import Node from "../core/Node.js";
+import CondNode from "../math/CondNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DiscardNode extends CondNode {
+    constructor(condNode: Node);
+}
+
+export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
+export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        discard: typeof discard;
+    }
+}

three/examples/jsm/nodes/utils/EquirectUVNode.d.ts

@@ -1,5 +1,5 @@
-import { PositionNode, TempNode } from '../Nodes.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { PositionNode, TempNode } from "../Nodes.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class EquirectUVNode extends TempNode {
     constructor(dirNode?: ShaderNodeObject<PositionNode>);

three/examples/jsm/nodes/utils/JoinNode.d.ts

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { TempNode } from '../Nodes.js';
+import Node from "../core/Node.js";
+import { TempNode } from "../Nodes.js";
 
 /**
  * This node constructs given type from elements, like vec3(a,b,c)

three/examples/jsm/nodes/utils/MatcapUVNode.d.ts

@@ -1,5 +1,5 @@
-import TempNode from '../core/TempNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class MatcapUVNode extends TempNode {
     constructor();

three/examples/jsm/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,7 +1,7 @@
-import { Texture } from '../../../../src/Three.js';
-import UniformNode from '../core/UniformNode.js';
-import TextureNode from '../accessors/TextureNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { Texture } from "../../../../src/Three.js";
+import TextureNode from "../accessors/TextureNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class MaxMipLevelNode extends UniformNode<0> {
     textureNode: TextureNode;

three/examples/jsm/nodes/utils/OscNode.d.ts

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type OscNodeMethod =
     | typeof OscNode.SINE
@@ -8,10 +8,10 @@ export type OscNodeMethod =
     | typeof OscNode.SAWTOOTH;
 
 export default class OscNode extends Node {
-    static SINE: 'sine';
-    static SQUARE: 'square';
-    static TRIANGLE: 'triangle';
-    static SAWTOOTH: 'sawtooth';
+    static SINE: "sine";
+    static SQUARE: "square";
+    static TRIANGLE: "triangle";
+    static SAWTOOTH: "sawtooth";
 
     method: OscNodeMethod;
     timeNode: Node;