@types/three 0.184.0 → 0.185.0

three/src/nodes/math/MathNode.d.ts

@@ -1,3 +1,7 @@
+import { Color } from "../../math/Color.js";
+import { Matrix2 } from "../../math/Matrix2.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";
@@ -143,17 +147,33 @@ export default class MathNode extends TempNode {
 }
 
 type FloatOrNumber = Node<"float"> | number;
-type IntOrNumber = Node<"int"> | number;
 type FloatVector = Node<"vec2"> | Node<"vec3"> | Node<"vec4">;
 type FloatVectorOrNumber = FloatOrNumber | Node<"vec2"> | Node<"vec3"> | Node<"vec4">;
 
-type BoolVector = Node<"bvec2"> | Node<"bvec3"> | Node<"bvec4">;
+type NumberVectorOrNumber =
+    | FloatVectorOrNumber
+    | Node<"int">
+    | Node<"uint">
+    | Node<"ivec2">
+    | Node<"ivec3">
+    | Node<"ivec4">
+    | Node<"uvec2">
+    | Node<"uvec3">
+    | Node<"uvec4">;
 
-type Matrix = Node<"mat2"> | Node<"mat3"> | Node<"mat4">;
+type Vec2 = Node<"vec2"> | Vector2;
+type Vec3 = Node<"vec3"> | Vector3 | Node<"color"> | Color;
+type Vec4 = Node<"vec4"> | Vector4;
 
-type Vec2OrLessOrFloat = FloatOrNumber | Node<"vec2">;
-type Vec3OrLessOrFloat = Vec2OrLessOrFloat | Node<"vec3">;
-type Vec4OrLessOrFloat = Vec3OrLessOrFloat | Node<"vec4">;
+type Vec2OrFloat = Vec2 | FloatOrNumber;
+type Vec3OrFloat = Vec3 | FloatOrNumber;
+type Vec4OrFloat = Vec4 | FloatOrNumber;
+
+type Mat2 = Node<"mat2"> | Matrix2;
+type Mat3 = Node<"mat3"> | Matrix3;
+type Mat4 = Node<"mat4"> | Matrix4;
+
+type Matrix = Mat2 | Mat3 | Mat4;
 
 export const EPSILON: Node<"float">;
 export const INFINITY: Node<"float">;
@@ -168,62 +188,52 @@ export const TWO_PI: Node<"float">;
 
 export const HALF_PI: Node<"float">;
 
-export const all: (x: BoolVector) => Node<"bool">;
-export const any: (x: BoolVector) => Node<"bool">;
+type BoolOrVector = Node<"bool"> | boolean | Node<"bvec2"> | Node<"bvec3"> | Node<"bvec4">;
+
+export const all: (x: BoolOrVector) => Node<"bool">;
+export const any: (x: BoolOrVector) => Node<"bool">;
 declare module "../core/Node.js" {
-    interface BvecExtensions {
+    interface BoolOrVecExtensions<TNodeType> {
         all: () => Node<"bool">;
         any: () => Node<"bool">;
     }
 }
 
-interface UnaryFunction {
+interface UnaryFloatVecFunction {
     (x: FloatOrNumber): Node<"float">;
-}
-export const radians: UnaryFunction;
-export const degrees: UnaryFunction;
-export const exp: UnaryFunction;
-export const exp2: UnaryFunction;
-export const log: UnaryFunction;
-export const log2: UnaryFunction;
-export const sqrt: UnaryFunction;
-export const inverseSqrt: UnaryFunction;
-declare module "../core/Node.js" {
-    interface FloatExtensions {
-        radians: () => Node<"float">;
-        degrees: () => Node<"float">;
-        exp: () => Node<"float">;
-        exp2: () => Node<"float">;
-        log: () => Node<"float">;
-        log2: () => Node<"float">;
-        sqrt: () => Node<"float">;
-        inverseSqrt: () => Node<"float">;
-    }
-}
-
-interface FloorCeil {
-    (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-}
-export const floor: FloorCeil;
-export const ceil: FloorCeil;
-declare module "../core/Node.js" {
-    interface FloatExtensions {
-        floor: () => Node<"float">;
-        ceil: () => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        floor: () => Node<TVec>;
-        ceil: () => Node<TVec>;
+    (x: Vec2): Node<"vec2">;
+    (x: Vec3): Node<"vec3">;
+    (x: Vec4): Node<"vec4">;
+}
+export const radians: UnaryFloatVecFunction;
+export const degrees: UnaryFloatVecFunction;
+export const exp: UnaryFloatVecFunction;
+export const exp2: UnaryFloatVecFunction;
+export const log: UnaryFloatVecFunction;
+export const log2: UnaryFloatVecFunction;
+export const sqrt: UnaryFloatVecFunction;
+export const inverseSqrt: UnaryFloatVecFunction;
+export const floor: UnaryFloatVecFunction;
+export const ceil: UnaryFloatVecFunction;
+declare module "../core/Node.js" {
+    interface FloatOrVecExtensions<TNodeType> {
+        radians: () => Node<TNodeType>;
+        degrees: () => Node<TNodeType>;
+        exp: () => Node<TNodeType>;
+        exp2: () => Node<TNodeType>;
+        log: () => Node<TNodeType>;
+        log2: () => Node<TNodeType>;
+        sqrt: () => Node<TNodeType>;
+        inverseSqrt: () => Node<TNodeType>;
+        floor: () => Node<TNodeType>;
+        ceil: () => Node<TNodeType>;
     }
 }
 
 interface Normalize {
-    (x: Node<"vec2"> | Vector2): Node<"vec2">;
-    (x: Node<"vec3"> | Vector3): Node<"vec3">;
-    (x: Node<"vec4"> | Vector4): Node<"vec4">;
+    (x: Vec2): Node<"vec2">;
+    (x: Vec3): Node<"vec3">;
+    (x: Vec4): Node<"vec4">;
 }
 export const normalize: Normalize;
 declare module "../core/Node.js" {
@@ -232,205 +242,181 @@ declare module "../core/Node.js" {
     }
 }
 
-interface Fract {
-    (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-}
-export const fract: Fract;
+interface ArcTanFunction {
+    (y: FloatOrNumber, x?: FloatOrNumber): Node<"float">;
+    (y: Vec2OrFloat, x?: Vec2OrFloat): Node<"vec2">;
+    (y: Vec3OrFloat, x?: Vec3OrFloat): Node<"vec3">;
+    (y: Vec4OrFloat, x?: Vec4OrFloat): Node<"vec4">;
+}
+
+export const fract: UnaryFloatVecFunction;
+export const sin: UnaryFloatVecFunction;
+export const sinh: UnaryFloatVecFunction;
+export const cos: UnaryFloatVecFunction;
+export const cosh: UnaryFloatVecFunction;
+export const tan: UnaryFloatVecFunction;
+export const tanh: UnaryFloatVecFunction;
+export const asin: UnaryFloatVecFunction;
+export const asinh: UnaryFloatVecFunction;
+export const acos: UnaryFloatVecFunction;
+export const acosh: UnaryFloatVecFunction;
+export const atan: ArcTanFunction;
+export const atanh: UnaryFloatVecFunction;
+
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        fract: () => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        fract: () => Node<TVec>;
+    interface FloatOrVecExtensions<TNodeType> {
+        fract: () => Node<TNodeType>;
+        sin: () => Node<TNodeType>;
+        sinh: () => Node<TNodeType>;
+        cos: () => Node<TNodeType>;
+        cosh: () => Node<TNodeType>;
+        tan: () => Node<TNodeType>;
+        tanh: () => Node<TNodeType>;
+        asin: () => Node<TNodeType>;
+        asinh: () => Node<TNodeType>;
+        acos: () => Node<TNodeType>;
+        acosh: () => Node<TNodeType>;
+        atanh: () => Node<TNodeType>;
     }
 }
 
-interface TrigonometricFunction {
-    (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-}
-interface ArcTanFunction {
-    (y: FloatOrNumber, x?: FloatOrNumber): Node<"float">;
-    (y: Node<"vec2">, x?: Vec2OrLessOrFloat): Node<"vec2">;
-    (y: Node<"vec3">, x?: Vec3OrLessOrFloat): Node<"vec3">;
-    (y: Node<"vec4">, x?: Vec4OrLessOrFloat): Node<"vec4">;
-}
-export const sin: TrigonometricFunction;
-export const sinh: TrigonometricFunction;
-export const cos: TrigonometricFunction;
-export const cosh: TrigonometricFunction;
-export const tan: TrigonometricFunction;
-export const tanh: TrigonometricFunction;
-export const asin: TrigonometricFunction;
-export const asinh: TrigonometricFunction;
-export const acos: TrigonometricFunction;
-export const acosh: TrigonometricFunction;
-export const atan: ArcTanFunction;
-export const atanh: TrigonometricFunction;
 declare module "../core/Node.js" {
     interface FloatExtensions {
-        sin: () => Node<"float">;
-        sinh: () => Node<"float">;
-        cos: () => Node<"float">;
-        cosh: () => Node<"float">;
-        tan: () => Node<"float">;
-        tanh: () => Node<"float">;
-        asin: () => Node<"float">;
-        asinh: () => Node<"float">;
-        acos: () => Node<"float">;
-        acosh: () => Node<"float">;
         atan: (x?: FloatOrNumber) => Node<"float">;
-        atanh: () => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        sin: () => Node<TVec>;
-        sinh: () => Node<TVec>;
-        cos: () => Node<TVec>;
-        cosh: () => Node<TVec>;
-        tan: () => Node<TVec>;
-        tanh: () => Node<TVec>;
-        asin: () => Node<TVec>;
-        asinh: () => Node<TVec>;
-        acos: () => Node<TVec>;
-        acosh: () => Node<TVec>;
-        atanh: () => Node<TVec>;
     }
     interface Vec2Extensions {
-        atan: (x?: Vec2OrLessOrFloat) => Node<"vec2">;
+        atan: (x?: Vec2OrFloat) => Node<"vec2">;
     }
     interface Vec3Extensions {
-        atan: (x?: Vec3OrLessOrFloat) => Node<"vec3">;
+        atan: (x?: Vec3OrFloat) => Node<"vec3">;
     }
     interface Vec4Extensions {
-        atan: (x?: Vec4OrLessOrFloat) => Node<"vec4">;
+        atan: (x?: Vec4OrFloat) => Node<"vec4">;
     }
 }
 
-interface Abs {
+interface UnaryNumVecFunction {
     (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-    (x: IntOrNumber): Node<"int">;
+    (x: Node<"int">): Node<"int">;
+    (x: Node<"uint">): Node<"uint">;
+    (x: Vec2): Node<"vec2">;
+    (x: Node<"ivec2">): Node<"ivec2">;
+    (x: Node<"uvec2">): Node<"uvec2">;
+    (x: Vec3): Node<"vec3">;
+    (x: Node<"ivec3">): Node<"ivec3">;
+    (x: Node<"uvec3">): Node<"uvec3">;
+    (x: Vec4): Node<"vec4">;
+    (x: Node<"ivec4">): Node<"ivec4">;
+    (x: Node<"uvec4">): Node<"uvec4">;
 }
-export const abs: Abs;
+
+export const abs: UnaryNumVecFunction;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        abs: () => Node<"float">;
+    interface FloatOrVecExtensions<TNodeType> {
+        abs: () => Node<TNodeType>;
     }
-    interface IntExtensions {
-        abs: () => Node<"int">;
+    interface IntOrVecExtensions<TNodeType> {
+        abs: () => Node<TNodeType>;
     }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        abs: () => Node<TVec>;
+    interface UintOrVecExtensions<TNodeType> {
+        abs: () => Node<TNodeType>;
     }
 }
 
-interface Sign {
+interface SignFunction {
     (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
+    (x: Node<"int">): Node<"int">;
+    (x: Vec2): Node<"vec2">;
+    (x: Node<"ivec2">): Node<"ivec2">;
+    (x: Vec3): Node<"vec3">;
+    (x: Node<"ivec3">): Node<"ivec3">;
+    (x: Vec4): Node<"vec4">;
+    (x: Node<"ivec4">): Node<"ivec4">;
 }
-export const sign: Sign;
+export const sign: SignFunction;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        sign: () => Node<"float">;
+    interface FloatOrVecExtensions<TNodeType> {
+        sign: () => Node<TNodeType>;
     }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        sign: () => Node<TVec>;
+    interface IntOrVecExtensions<TNodeType> {
+        sign: () => Node<TNodeType>;
     }
 }
 
-export const length: (x: FloatVector | Node) => Node<"float">;
+export const length: (x: NumberVectorOrNumber) => Node<"float">;
 declare module "../core/Node.js" {
-    interface FloatVecExtensions<TVec extends FloatVecType> {
+    interface FloatOrVecExtensions<TNodeType> {
+        length: () => Node<"float">;
+    }
+    interface IntOrVecExtensions<TNodeType> {
         length: () => Node<"float">;
     }
 }
 
-interface Negate {
+interface NegateFunction {
     (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
+    (x: Node<"int">): Node<"int">;
+    (x: Vec2): Node<"vec2">;
+    (x: Node<"ivec2">): Node<"ivec2">;
+    (x: Vec3): Node<"vec3">;
+    (x: Node<"ivec3">): Node<"ivec3">;
+    (x: Vec4): Node<"vec4">;
+    (x: Node<"ivec4">): Node<"ivec4">;
 }
-export const negate: Negate;
+export const negate: NegateFunction;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        negate: () => Node<"float">;
+    interface FloatOrVecExtensions<TNodeType> {
+        negate: () => Node<TNodeType>;
     }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        negate: () => Node<TVec>;
+    interface IntOrVecExtensions<TNodeType> {
+        negate: () => Node<TNodeType>;
     }
 }
 
-interface OneMinus {
-    (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-}
-export const oneMinus: OneMinus;
+export const oneMinus: UnaryFloatVecFunction;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        oneMinus: () => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        oneMinus: () => Node<TVec>;
+    interface FloatOrVecExtensions<TNodeType> {
+        oneMinus: () => Node<TNodeType>;
     }
 }
 
-interface Derivative {
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-}
-export const dFdx: Derivative;
-export const dFdy: Derivative;
+export const dFdx: UnaryFloatVecFunction;
+export const dFdy: UnaryFloatVecFunction;
 declare module "../core/Node.js" {
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        dFdx: () => Node<TVec>;
-        dFdy: () => Node<TVec>;
+    interface FloatOrVecExtensions<TNodeType> {
+        dFdx: () => Node<TNodeType>;
+        dFdy: () => Node<TNodeType>;
     }
 }
 
-export const round: (x: FloatOrNumber) => Node<"float">;
-export const reciprocal: (x: FloatOrNumber) => Node<"float">;
-export const trunc: (x: FloatOrNumber) => Node<"float">;
+export const round: UnaryNumVecFunction;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        round: () => Node<"float">;
-        reciprocal: () => Node<"float">;
-        trunc: () => Node<"float">;
+    interface FloatOrVecExtensions<TNodeType> {
+        round: () => Node<TNodeType>;
+    }
+    interface IntOrVecExtensions<TNodeType> {
+        round: () => Node<TNodeType>;
+    }
+    interface UintOrVecExtensions<TNodeType> {
+        round: () => Node<TNodeType>;
     }
 }
 
-interface Fwidth {
-    (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
-}
-export const fwidth: Fwidth;
+export const reciprocal: UnaryFloatVecFunction;
+export const trunc: UnaryFloatVecFunction;
+export const fwidth: UnaryFloatVecFunction;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        fwidth: () => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        fwidth: () => Node<TVec>;
+    interface FloatOrVecExtensions<TNodeType> {
+        reciprocal: () => Node<TNodeType>;
+        trunc: () => Node<TNodeType>;
+        fwidth: () => Node<TNodeType>;
     }
 }
 
 interface Transpose {
-    (x: Node<"mat2">): Node<"mat2">;
-    (x: Node<"mat3">): Node<"mat3">;
-    (x: Node<"mat4">): Node<"mat4">;
+    (x: Mat2): Node<"mat2">;
+    (x: Mat3): Node<"mat3">;
+    (x: Mat4): Node<"mat4">;
 }
 export const transpose: Transpose;
 declare module "../core/Node.js" {
@@ -447,9 +433,9 @@ declare module "../core/Node.js" {
 }
 
 interface Inverse {
-    (x: Node<"mat2">): Node<"mat2">;
-    (x: Node<"mat3">): Node<"mat3">;
-    (x: Node<"mat4">): Node<"mat4">;
+    (x: Mat2): Node<"mat2">;
+    (x: Mat3): Node<"mat3">;
+    (x: Mat4): Node<"mat4">;
 }
 export const inverse: Inverse;
 declare module "../core/Node.js" {
@@ -458,31 +444,32 @@ declare module "../core/Node.js" {
     }
 }
 
+// TODO Allow int/uint
 interface MinMax {
     (x: FloatOrNumber, y: FloatOrNumber, ...params: FloatOrNumber[]): Node<"float">;
-    (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">;
-    (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
-    (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+    (x: Vec2OrFloat, y: Vec2OrFloat, ...params: Vec2OrFloat[]): Node<"vec2">;
+    (x: Vec3OrFloat, y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">;
+    (x: Vec4OrFloat, y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">;
 }
 export const min: MinMax;
 export const max: MinMax;
 interface MinMaxFloatExtension {
     (y: FloatOrNumber, ...params: FloatOrNumber[]): Node<"float">;
-    (y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">;
-    (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
-    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+    (y: Vec2OrFloat, ...params: Vec2OrFloat[]): Node<"vec2">;
+    (y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">;
+    (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">;
 }
 interface MinMaxVec2Extension {
-    (y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">;
-    (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
-    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+    (y: Vec2OrFloat, ...params: Vec2OrFloat[]): Node<"vec2">;
+    (y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">;
+    (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">;
 }
 interface MinMaxVec3Extension {
-    (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">;
-    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+    (y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">;
+    (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">;
 }
 interface MinMaxVec4Extension {
-    (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">;
+    (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface FloatExtensions {
@@ -503,25 +490,28 @@ declare module "../core/Node.js" {
     }
 }
 
-export const step: (x: FloatOrNumber, y: FloatOrNumber) => Node<"float">;
+interface Step {
+    (edge: FloatOrNumber, x: FloatOrNumber): Node<"float">;
+    (edge: Vec2OrFloat, x: Vec2OrFloat): Node<"vec2">;
+    (edge: Vec3OrFloat, x: Vec3OrFloat): Node<"vec3">;
+    (edge: Vec4OrFloat, x: Vec4OrFloat): Node<"vec4">;
+}
+export const step: Step;
 
 interface Reflect {
-    (I: Vec2OrLessOrFloat, N: Vec2OrLessOrFloat): Node<"vec2">;
-    (I: Vec3OrLessOrFloat, N: Vec3OrLessOrFloat): Node<"vec3">;
-    (I: Vec4OrLessOrFloat, N: Vec4OrLessOrFloat): Node<"vec4">;
+    (I: Vec2OrFloat, N: Vec2OrFloat): Node<"vec2">;
+    (I: Vec3OrFloat, N: Vec3OrFloat): Node<"vec3">;
+    (I: Vec4OrFloat, N: Vec4OrFloat): Node<"vec4">;
 }
 export const reflect: Reflect;
 interface ReflectVec2Extension {
-    (N: Vec2OrLessOrFloat): Node<"vec2">;
-    (N: Vec3OrLessOrFloat): Node<"vec3">;
-    (N: Vec4OrLessOrFloat): Node<"vec4">;
+    (N: Vec2OrFloat): Node<"vec2">;
 }
 interface ReflectVec3Extension {
-    (N: Vec3OrLessOrFloat): Node<"vec3">;
-    (N: Vec4OrLessOrFloat): Node<"vec4">;
+    (N: Vec3OrFloat): Node<"vec3">;
 }
 interface ReflectVec4Extension {
-    (N: Vec4OrLessOrFloat): Node<"vec4">;
+    (N: Vec4OrFloat): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface Vec2Extensions {
@@ -537,38 +527,33 @@ declare module "../core/Node.js" {
 
 export const distance: (x: FloatVectorOrNumber, y: FloatVectorOrNumber) => Node<"float">;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        distance: (y: FloatVectorOrNumber) => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
+    interface FloatOrVecExtensions<TNodeType> {
         distance: (y: FloatVectorOrNumber) => Node<"float">;
     }
 }
 
+// TODO Allow int/uint
 interface Difference {
     (x: FloatOrNumber, y: FloatOrNumber): Node<"float">;
-    (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat): Node<"vec2">;
-    (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat): Node<"vec3">;
-    (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat): Node<"vec4">;
+    (x: Vec2OrFloat, y: Vec2OrFloat): Node<"vec2">;
+    (x: Vec3OrFloat, y: Vec3OrFloat): Node<"vec3">;
+    (x: Vec4OrFloat, y: Vec4OrFloat): Node<"vec4">;
 }
 export const difference: Difference;
 interface DifferenceFloatExtension {
     (y: FloatOrNumber): Node<"float">;
-    (y: Vec2OrLessOrFloat): Node<"vec2">;
-    (y: Vec3OrLessOrFloat): Node<"vec3">;
-    (y: Vec4OrLessOrFloat): Node<"vec4">;
+    (y: Vec2OrFloat): Node<"vec2">;
+    (y: Vec3OrFloat): Node<"vec3">;
+    (y: Vec4OrFloat): Node<"vec4">;
 }
 interface DifferenceVec2Extension {
-    (y: Vec2OrLessOrFloat): Node<"vec2">;
-    (y: Vec3OrLessOrFloat): Node<"vec3">;
-    (y: Vec4OrLessOrFloat): Node<"vec4">;
+    (y: Vec2OrFloat): Node<"vec2">;
 }
 interface DifferenceVec3Extension {
-    (y: Vec3OrLessOrFloat): Node<"vec3">;
-    (y: Vec4OrLessOrFloat): Node<"vec4">;
+    (y: Vec3OrFloat): Node<"vec3">;
 }
 interface DifferenceVec4Extension {
-    (y: Vec4OrLessOrFloat): Node<"vec4">;
+    (y: Vec4OrFloat): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface FloatExtensions {
@@ -585,6 +570,7 @@ declare module "../core/Node.js" {
     }
 }
 
+// TODO Allow int/uint
 export const dot: (x: FloatVector, y: FloatVector) => Node<"float">;
 declare module "../core/Node.js" {
     interface FloatVecExtensions<TVec extends FloatVecType> {
@@ -592,55 +578,95 @@ declare module "../core/Node.js" {
     }
 }
 
-export const cross: (x: Node<"vec3">, y: Node<"vec3">) => Node<"vec3">;
+export const cross: (x: Vec3, y: Vec3) => Node<"vec3">;
 declare module "../core/Node.js" {
     interface Vec3Extensions {
-        cross: (y: Node<"vec3">) => Node<"vec3">;
+        cross: (y: Vec3) => Node<"vec3">;
     }
 }
 
 interface Pow {
     (x: FloatOrNumber, y: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">, y: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">, y: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">, y: Node<"vec4">): Node<"vec4">;
+    (x: Vec2OrFloat, y: Vec2OrFloat): Node<"vec2">;
+    (x: Vec3OrFloat, y: Vec3OrFloat): Node<"vec3">;
+    (x: Vec4OrFloat, y: Vec4OrFloat): Node<"vec4">;
+}
+export const pow: Pow;
+interface PowFloatExtension {
+    (y: FloatOrNumber): Node<"float">;
+    (y: Vec2OrFloat): Node<"vec2">;
+    (y: Vec3OrFloat): Node<"vec3">;
+    (y: Vec4OrFloat): Node<"vec4">;
+}
+interface PowVec2Extension {
+    (y: Vec2OrFloat): Node<"vec2">;
+}
+interface PowVec3Extension {
+    (y: Vec3OrFloat): Node<"vec3">;
+}
+interface PowVec4Extension {
+    (y: Vec4OrFloat): Node<"vec4">;
 }
-export const pow: (x: FloatOrNumber, y: FloatOrNumber) => Node<"float">;
 declare module "../core/Node.js" {
     interface FloatExtensions {
-        pow: (y: FloatOrNumber) => Node<"float">;
+        pow: PowFloatExtension;
     }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        pow: (y: Node<TVec>) => Node<TVec>;
+    interface Vec2Extensions {
+        pow: PowVec2Extension;
+    }
+    interface Vec3Extensions {
+        pow: PowVec3Extension;
+    }
+    interface Vec4Extensions {
+        pow: PowVec4Extension;
     }
 }
 
 interface PowConstant {
     (x: FloatOrNumber): Node<"float">;
-    (x: Node<"vec2">): Node<"vec2">;
-    (x: Node<"vec3">): Node<"vec3">;
-    (x: Node<"vec4">): Node<"vec4">;
+    (x: Vec2): Node<"vec2">;
+    (x: Vec3): Node<"vec3">;
+    (x: Vec4): Node<"vec4">;
 }
 export const pow2: PowConstant;
 export const pow3: PowConstant;
 export const pow4: PowConstant;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        pow2: () => Node<"float">;
-        pow3: () => Node<"float">;
-        pow4: () => Node<"float">;
+    interface FloatOrVecExtensions<TNodeType> {
+        pow2: () => Node<TNodeType>;
+        pow3: () => Node<TNodeType>;
+        pow4: () => Node<TNodeType>;
     }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        pow2: () => Node<TVec>;
-        pow3: () => Node<TVec>;
-        pow4: () => Node<TVec>;
+}
+
+interface TransformDirection {
+    (direction: Vec3, matrix: Mat3 | Mat4): Node<"vec3">;
+    (matrix: Mat3 | Mat4, direction: Vec3): Node<"vec3">;
+}
+
+export const transformDirection: TransformDirection;
+declare module "../core/Node.js" {
+    interface Vec3Extensions {
+        transformDirection: (matrix: Mat3 | Mat4) => Node<"vec3">;
+    }
+    interface Mat3Extensions {
+        transformDirection: (direction: Vec3) => Node<"vec3">;
+    }
+    interface Mat4Extensions {
+        transformDirection: (direction: Vec3) => Node<"vec3">;
     }
 }
 
-export const transformDirection: (direction: Node<"vec3">, matrix: Node<"mat3"> | Node<"mat4">) => Node<"vec3">;
+interface TransformNormalByViewMatrix {
+    (normal: Vec3, viewMatrix: Mat3 | Mat4): Node<"vec3">;
+}
+
+export const transformNormalByViewMatrix: TransformNormalByViewMatrix;
+export const transformNormalByInverseViewMatrix: TransformNormalByViewMatrix;
 declare module "../core/Node.js" {
     interface Vec3Extensions {
-        transformDirection: (matrix: Node<"mat3"> | Node<"mat4">) => Node<"vec3">;
+        transformNormalByViewMatrix: (matrix: Mat3 | Mat4) => Node<"vec3">;
+        transformNormalByInverseViewMatrix: (matrix: Mat3 | Mat4) => Node<"vec3">;
     }
 }
 
@@ -660,36 +686,34 @@ declare module "../core/Node.js" {
 
 interface Mix {
     (a: FloatOrNumber, b: FloatOrNumber, t: FloatOrNumber): Node<"float">;
-    (a: Vec2OrLessOrFloat, b: Vec2OrLessOrFloat, t: FloatOrNumber): Node<"vec2">;
-    (a: Vec3OrLessOrFloat | Node<"color">, b: Vec3OrLessOrFloat | Node<"color">, t: FloatOrNumber): Node<"vec3">;
-    (a: Vec4OrLessOrFloat, b: Vec4OrLessOrFloat, t: FloatOrNumber): Node<"vec4">;
+    (a: Vec2OrFloat, b: Vec2OrFloat, t: FloatOrNumber): Node<"vec2">;
+    (a: Vec3OrFloat, b: Vec3OrFloat, t: FloatOrNumber): Node<"vec3">;
+    (a: Vec4OrFloat | Vec3, b: Vec4OrFloat | Vec3, t: FloatOrNumber): Node<"vec4">;
 }
 export const mix: Mix;
 
+// TODO Allow int/uint
 interface Clamp {
     (value: FloatOrNumber, low?: FloatOrNumber, high?: FloatOrNumber): Node<"float">;
-    (value: Vec2OrLessOrFloat, low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">;
-    (value: Vec3OrLessOrFloat, low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
-    (value: Vec4OrLessOrFloat, low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+    (value: Vec2OrFloat, low?: Vec2OrFloat, high?: Vec2OrFloat): Node<"vec2">;
+    (value: Vec3OrFloat, low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">;
+    (value: Vec4OrFloat, low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">;
 }
 export const clamp: Clamp;
 interface ClampFloatExtension {
     (low?: FloatOrNumber, high?: FloatOrNumber): Node<"float">;
-    (low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">;
-    (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
-    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+    (low?: Vec2OrFloat, high?: Vec2OrFloat): Node<"vec2">;
+    (low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">;
+    (low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">;
 }
 interface ClampVec2Extension {
-    (low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">;
-    (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
-    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+    (low?: Vec2OrFloat, high?: Vec2OrFloat): Node<"vec2">;
 }
 interface ClampVec3Extension {
-    (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">;
-    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+    (low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">;
 }
 interface ClampVec4Extension {
-    (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">;
+    (low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface FloatExtensions {
@@ -708,37 +732,31 @@ declare module "../core/Node.js" {
 
 interface Saturate {
     (value: FloatOrNumber): Node<"float">;
-    (value: Node<"vec2">): Node<"vec2">;
-    (value: Node<"vec3">): Node<"vec3">;
-    (value: Node<"vec4">): Node<"vec4">;
+    (value: Vec2): Node<"vec2">;
+    (value: Vec3): Node<"vec3">;
+    (value: Vec4): Node<"vec4">;
 }
 export const saturate: Saturate;
 declare module "../core/Node.js" {
-    interface FloatExtensions {
-        saturate: () => Node<"float">;
-    }
-    interface FloatVecExtensions<TVec extends FloatVecType> {
-        saturate: () => Node<TVec>;
+    interface FloatOrVecExtensions<TNodeType> {
+        saturate: () => Node<TNodeType>;
     }
 }
 
 interface Refract {
-    (I: Vec2OrLessOrFloat, N: Vec2OrLessOrFloat, ratio: FloatOrNumber): Node<"vec2">;
-    (I: Vec3OrLessOrFloat, N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">;
-    (I: Vec4OrLessOrFloat, N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+    (I: Vec2OrFloat, N: Vec2OrFloat, ratio: FloatOrNumber): Node<"vec2">;
+    (I: Vec3OrFloat, N: Vec3OrFloat, ratio: FloatOrNumber): Node<"vec3">;
+    (I: Vec4OrFloat, N: Vec4OrFloat, ratio: FloatOrNumber): Node<"vec4">;
 }
 export const refract: Refract;
 interface RefractVec2Extension {
-    (N: Vec2OrLessOrFloat, ratio: FloatOrNumber): Node<"vec2">;
-    (N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">;
-    (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+    (N: Vec2OrFloat, ratio: FloatOrNumber): Node<"vec2">;
 }
 interface RefractVec3Extension {
-    (N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">;
-    (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+    (N: Vec3OrFloat, ratio: FloatOrNumber): Node<"vec3">;
 }
 interface RefractVec4Extension {
-    (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">;
+    (N: Vec4OrFloat, ratio: FloatOrNumber): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface Vec2Extensions {
@@ -754,26 +772,26 @@ declare module "../core/Node.js" {
 
 interface Smoothstep {
     (low: FloatOrNumber, high: FloatOrNumber, x: FloatOrNumber): Node<"float">;
+    (low: Vec2OrFloat, high: Vec2OrFloat, x: Vec2OrFloat): Node<"vec2">;
+    (low: Vec3OrFloat, high: Vec3OrFloat, x: Vec3OrFloat): Node<"vec3">;
+    (low: Vec4OrFloat, high: Vec4OrFloat, x: Vec4OrFloat): Node<"vec4">;
 }
 export const smoothstep: Smoothstep;
 
 interface FaceForward {
-    (N: Vec2OrLessOrFloat, I: Vec2OrLessOrFloat, Nref: Vec2OrLessOrFloat): Node<"vec2">;
-    (N: Vec3OrLessOrFloat, I: Vec3OrLessOrFloat, Nref: Vec3OrLessOrFloat): Node<"vec3">;
-    (N: Vec4OrLessOrFloat, I: Vec4OrLessOrFloat, Nref: Vec4OrLessOrFloat): Node<"vec4">;
+    (N: Vec2OrFloat, I: Vec2OrFloat, Nref: Vec2OrFloat): Node<"vec2">;
+    (N: Vec3OrFloat, I: Vec3OrFloat, Nref: Vec3OrFloat): Node<"vec3">;
+    (N: Vec4OrFloat, I: Vec4OrFloat, Nref: Vec4OrFloat): Node<"vec4">;
 }
 export const faceForward: FaceForward;
 interface FaceForwardVec2Extension {
-    (I: Vec2OrLessOrFloat, Nref: Vec2OrLessOrFloat): Node<"vec2">;
-    (I: Vec3OrLessOrFloat, Nref: Vec3OrLessOrFloat): Node<"vec3">;
-    (I: Vec4OrLessOrFloat, Nref: Vec4OrLessOrFloat): Node<"vec4">;
+    (I: Vec2OrFloat, Nref: Vec2OrFloat): Node<"vec2">;
 }
 interface FaceForwardVec3Extension {
-    (N: Vec3OrLessOrFloat, ratio: Vec3OrLessOrFloat): Node<"vec3">;
-    (N: Vec4OrLessOrFloat, ratio: Vec4OrLessOrFloat): Node<"vec4">;
+    (N: Vec3OrFloat, ratio: Vec3OrFloat): Node<"vec3">;
 }
 interface FaceForwardVec4Extension {
-    (N: Vec4OrLessOrFloat, ratio: Vec4OrLessOrFloat): Node<"vec4">;
+    (N: Vec4OrFloat, ratio: Vec4OrFloat): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface Vec2Extensions {
@@ -787,7 +805,7 @@ declare module "../core/Node.js" {
     }
 }
 
-export const rand: (uv: Node<"vec2">) => Node<"float">;
+export const rand: (uv: Vec2) => Node<"float">;
 declare module "../core/Node.js" {
     interface Vec2Extensions {
         rand: () => Node<"float">;
@@ -796,16 +814,16 @@ declare module "../core/Node.js" {
 
 interface MixElement {
     (t: FloatOrNumber, e1: FloatOrNumber, e2: FloatOrNumber): Node<"float">;
-    (t: FloatOrNumber, e1: Vec2OrLessOrFloat, e2: Vec2OrLessOrFloat): Node<"vec2">;
-    (t: FloatOrNumber, e1: Vec3OrLessOrFloat | Node<"color">, e2: Vec3OrLessOrFloat | Node<"color">): Node<"vec3">;
-    (t: FloatOrNumber, e1: Vec4OrLessOrFloat, e2: Vec4OrLessOrFloat): Node<"vec4">;
+    (t: FloatOrNumber, e1: Vec2OrFloat, e2: Vec2OrFloat): Node<"vec2">;
+    (t: FloatOrNumber, e1: Vec3OrFloat, e2: Vec3OrFloat): Node<"vec3">;
+    (t: FloatOrNumber, e1: Vec4OrFloat | Vec3, e2: Vec4OrFloat | Vec3): Node<"vec4">;
 }
 export const mixElement: MixElement;
 interface MixExtension {
     (e1: FloatOrNumber, e2: FloatOrNumber): Node<"float">;
-    (e1: Vec2OrLessOrFloat, e2: Vec2OrLessOrFloat): Node<"vec2">;
-    (e1: Vec3OrLessOrFloat | Node<"color">, e2: Vec3OrLessOrFloat | Node<"color">): Node<"vec3">;
-    (e1: Vec4OrLessOrFloat | Node<"color">, e2: Vec4OrLessOrFloat | Node<"color">): Node<"vec4">;
+    (e1: Vec2OrFloat, e2: Vec2OrFloat): Node<"vec2">;
+    (e1: Vec3OrFloat, e2: Vec3OrFloat): Node<"vec3">;
+    (e1: Vec4OrFloat | Vec3, e2: Vec4OrFloat | Vec3): Node<"vec4">;
 }
 declare module "../core/Node.js" {
     interface FloatExtensions {
@@ -815,22 +833,58 @@ declare module "../core/Node.js" {
 
 interface SmoothstepElement {
     (x: FloatOrNumber, low: FloatOrNumber, high: FloatOrNumber): Node<"float">;
+    (x: Vec2OrFloat, low: Vec2OrFloat, high: Vec2OrFloat): Node<"vec2">;
+    (x: Vec3OrFloat, low: Vec3OrFloat, high: Vec3OrFloat): Node<"vec3">;
+    (x: Vec4OrFloat, low: Vec4OrFloat, high: Vec4OrFloat): Node<"vec4">;
 }
 export const smoothstepElement: SmoothstepElement;
-interface SmoothstepExtension {
+interface SmoothstepFloatExtension {
     (low: FloatOrNumber, high: FloatOrNumber): Node<"float">;
 }
+interface SmoothstepVec2Extension {
+    (low: Vec2OrFloat, high: Vec2OrFloat): Node<"vec2">;
+}
+interface SmoothstepVec3Extension {
+    (low: Vec3OrFloat, high: Vec3OrFloat): Node<"vec3">;
+}
+interface SmoothstepVec4Extension {
+    (low: Vec4OrFloat, high: Vec4OrFloat): Node<"vec4">;
+}
 declare module "../core/Node.js" {
     interface FloatExtensions {
-        smoothstep: SmoothstepExtension;
+        smoothstep: SmoothstepFloatExtension;
+    }
+    interface Vec2Extensions {
+        smoothstep: SmoothstepVec2Extension;
+    }
+    interface Vec3Extensions {
+        smoothstep: SmoothstepVec3Extension;
+    }
+    interface Vec4Extensions {
+        smoothstep: SmoothstepVec4Extension;
     }
 }
 
-export const stepElement: (x: FloatOrNumber, edge: FloatOrNumber) => Node<"float">;
+interface StepElement {
+    (x: FloatOrNumber, edge: FloatOrNumber): Node<"float">;
+    (x: Vec2OrFloat, edge: Vec2OrFloat): Node<"vec2">;
+    (x: Vec3OrFloat, edge: Vec3OrFloat): Node<"vec3">;
+    (x: Vec4OrFloat, edge: Vec4OrFloat): Node<"vec4">;
+}
+export const stepElement: StepElement;
 declare module "../core/Node.js" {
     interface FloatExtensions {
         step: (edge: FloatOrNumber) => Node<"float">;
     }
+    interface Vec2Extensions {
+        step: (edge: Vec2OrFloat) => Node<"vec2">;
+    }
+    interface Vec3Extensions {
+        step: (edge: Vec3OrFloat) => Node<"vec3">;
+    }
+    interface Vec4Extensions {
+        step: (edge: Vec4OrFloat) => Node<"vec4">;
+    }
 }
 
 // GLSL alias function