@ntf/math 1.3.2 → 1.4.1

package/dist/index.d.mts

@@ -1,12 +1,6 @@
-declare function stringify<V>(value: V): string;
-interface IToString {
-    /**
-     * Returns a string representation of an object.
-     */
-    toString(): string;
-}
+import { IToString, NodeJSCustomInspect, FixedArray } from '@ntf/types';
 
-interface IGeometryObject {
+interface IGeometryObject extends IToString {
     readonly area: number;
     readonly perimeter: number;
 }
@@ -15,281 +9,46 @@ interface ISize {
     width: number;
     height: number;
 }
+interface IToSize {
+    toSize(): SizeLike;
+}
 type SizeArray = [number, number];
 type SizeString = `${number}x${number}`;
-type SizeLike = ISize | SizeArray | SizeString | number;
-type SizeArguments = [SizeLike] | [number, number];
-declare class Size implements ISize, IGeometryObject, IToString {
+type SizeLike = ISize | SizeArray | SizeString | number | IToSize;
+type SizeArguments = [size: SizeLike] | SizeArray;
+declare class Size implements ISize, IGeometryObject, IToVec2 {
     width: number;
     height: number;
     get aspectRatio(): number;
     get area(): number;
     get perimeter(): number;
     static resolve(a: unknown): Size;
+    static resolveArgs(args: SizeArguments): Size;
     static cast(a: unknown): Size | undefined;
     static is(a: unknown): a is SizeLike;
     constructor(width: number, height: number);
     toArray(): SizeArray;
     toString(): SizeString;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     toJSON(): ISize;
     clone(): Size;
-    equals(square: SizeLike): boolean;
-    toVec2(): Vec2Like;
-}
-
-interface IVec3 extends IVec2 {
-    z: number;
-}
-type Vec3Array = [number, number, number] | [number, number, number, number];
-type Vec3String = `${number},${number},${number}` | `${number},${number},${number};${number}`;
-type Vec3Like = IVec3 | Vec3Array | Vec3String | number;
-type Vec3Arguments = [Vec3Like] | [number, number, number];
-declare class Vec3 implements IVec3 {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-    static resolve(a: unknown): Vec3;
-    static cast(a: unknown): Vec3 | undefined;
-    static resolveArgs(args: Vec3Arguments): Vec3;
-    static is(a: unknown): a is Vec3Like;
-    static fromPoints(a: Vec3Like, b: Vec3Like): Vec3;
-    static clamp(value: Vec3Like, min: Vec3Like, max: Vec3Like): Vec3;
-    static intersectPlane(planeP: Vec3Like, planeN: Vec3Like, lineStart: Vec3Like, lineEnd: Vec3Like, t: number): Vec3;
-    constructor(x?: number, y?: number, z?: number, w?: number);
-    toArray(w?: boolean): Vec3Array;
-    toJSON(): IVec3;
-    toString(w?: boolean): Vec3String;
+    equals(size: SizeLike): boolean;
+    equals(width: number, height: number): boolean;
     toVec2(): Vec2Like;
-    clone(): Vec3;
-    equals(vec: Vec3Like): boolean;
-    setX(x: number): this;
-    setY(y: number): this;
-    setZ(z: number): this;
-    set(x: number, y: number, z: number): this;
-    set(vec: Vec3Like): this;
-    add(x: number, y: number, z: number): Vec3;
-    add(vec: Vec3Like): Vec3;
-    offset(x: number, y: number, z: number): this;
-    offset(vec: Vec3Like): this;
-    subtract(x: number, y: number, z: number): Vec3;
-    subtract(vec: Vec3Like): Vec3;
-    multiply(scalar: number): Vec3;
-    naiveMultiply(x: number, y: number, z: number): Vec3;
-    naiveMultiply(vec: Vec3Like): Vec3;
-    divide(x: number, y: number, z: number): Vec3;
-    divide(scalar: number): Vec3;
-    divide(vec: Vec3Like): Vec3;
-    dot(x: number, y: number, z: number): number;
-    dot(vec: Vec3Like): number;
-    cross(x: number, y: number, z: number): Vec3;
-    cross(vec: Vec3Like): Vec3;
-    distance(x: number, y: number, z: number): number;
-    distance(vec: Vec3Like): number;
-    distanceSquare(x: number, y: number, z: number): number;
-    distanceSquare(vec: Vec3Like): number;
-    length(): number;
-    normalize(): Vec3;
-    invert(): Vec3;
-    round(): Vec3;
-}
-
-interface IVec2 {
-    x: number;
-    y: number;
-    w: number;
-}
-type Vec2Array = [number, number] | [number, number, number];
-type Vec2String = `${number},${number}` | `${number},${number};${number}`;
-type Vec2Like = IVec2 | Vec2Array | Vec2String | number;
-type Vec2Arguments = [Vec2Like] | [number, number];
-declare class Vec2 implements IVec2 {
-    x: number;
-    y: number;
-    w: number;
-    static resolve(a: unknown): Vec2;
-    static cast(a: unknown): Vec2 | undefined;
-    static resolveArgs(args: Vec2Arguments): Vec2;
-    static is(a: unknown): a is Vec2Like;
-    static fromPoints(a: Vec2Like, b: Vec2Like): Vec2;
-    static clamp(value: Vec2Like, min: Vec2Like, max: Vec2Like): Vec2;
-    constructor(x?: number, y?: number, w?: number);
-    toArray(w?: boolean): Vec2Array;
-    toJSON(): IVec2;
-    toString(w?: boolean): Vec2String;
-    toSquare(): Size;
-    toVec3(z?: number): Vec3;
-    clone(): Vec2;
-    equals(vec: Vec2Like): boolean;
-    setX(x: number): this;
-    setY(y: number): this;
-    setW(w: number): this;
-    set(x: number, y: number): this;
-    set(vec: Vec2Like): this;
-    add(x: number, y: number): Vec2;
-    add(vec: Vec2Like): Vec2;
-    offset(x: number, y: number): this;
-    offset(vec: Vec2Like): this;
-    subtract(x: number, y: number): Vec2;
-    subtract(vec: Vec2Like): Vec2;
-    multiply(scalar: number): Vec2;
-    naiveMultiply(x: number, y: number): Vec2;
-    naiveMultiply(vec: Vec2Like): Vec2;
-    divide(x: number, y: number): Vec2;
-    divide(scalar: number): Vec2;
-    divide(vec: Vec2Like): Vec2;
-    dot(x: number, y: number): number;
-    dot(vec: Vec2Like): number;
-    distance(x: number, y: number): number;
-    distance(vec: Vec2Like): number;
-    distanceSquare(x: number, y: number): number;
-    distanceSquare(vec: Vec2Like): number;
-    length(): number;
-    cartesianify(): Vec2;
-    polarify(): Vec2;
-    normalize(): Vec2;
-    invert(): Vec2;
-    round(): Vec2;
-}
-
-/**
- * An abstract class of a mathematical function
- * @template Input The amount of input values the function can use
- */
-declare abstract class MathFunction<Input extends Array<number> = Array<number>> implements IToString {
-    /**
-     * Calculate y with input values
-     * @param args The input values
-     * @returns The y value from the input values
-     */
-    abstract get(...args: Input): number;
-    /**
-     * Get the root points of this function
-     * @returns The root points, this can be an empty array if no root points have been found
-     */
-    abstract roots(): Array<Vec2>;
-}
-
-/**
- * The string representation of a linear function
- */
-type LinearFunctionString = `f(x) = ${number} * x ${"+" | "-"} ${number}` | `f(x) = ${number} * x`;
-/**
- * A class that implements a linear function with `m`, `b` and `x`
- */
-declare class LinearFunction extends MathFunction<[number]> {
-    /**
-     * The factor of the linear function
-     */
-    m: number;
-    /**
-     * The height of the linear function
-     */
-    b: number;
-    /**
-     * Create a linear function from two points
-     * @param a A point
-     * @param b A point
-     * @returns A linear function from two points
-     */
-    static fromPoints(a: Vec2Like, b: Vec2Like): LinearFunction;
-    /**
-     * Create a linear function with a factor and height
-     * @param m The factor
-     * @param b The height
-     */
-    constructor(m: number, b: number);
-    get(x: number): number;
-    roots(): Array<Vec2>;
-    toString(): LinearFunctionString;
-}
-
-type QuadFunctionType = "standard";
-type QuadFunctionString = {
-    "standard": `f(x) = ${number}x^2 ${"+" | "-"} ${number}x ${"+" | "-"} ${number}` | `f(x) = ${number}x^2 ${"+" | "-"} ${number}x` | `f(x) = ${number}x^2`;
-};
-type QuadFunctionStrings = QuadFunctionString[QuadFunctionType];
-declare class QuadFunction extends MathFunction<[number]> {
-    a: number;
-    b: number;
-    c: number;
-    static get(a: number, b: number, c: number, x: number): number;
-    constructor(a: number, b: number, c: number);
-    get(x: number): number;
-    roots(): Array<Vec2>;
-    toString<T extends QuadFunctionType>(type?: T): QuadFunctionString[T];
-}
-
-declare class ResolveError extends Error {
-    readonly target: string;
-    readonly value: unknown;
-    constructor(target: string, value: unknown);
-}
-
-declare function sign_char(num: number | bigint): "-" | "+" | undefined;
-
-type JavaScriptTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-type JavaScriptTypeMap = {
-    "string": string;
-    "number": number;
-    "bigint": bigint;
-    "boolean": boolean;
-    "symbol": symbol;
-    "undefined": undefined;
-    "object": object;
-    "function": Function;
-};
-type HexDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F";
-type HexLike = `$${string}` | `#${string}` | `0x${string}` | string;
-type Predicate<T> = (a: unknown) => a is T;
-declare function check_number(obj: unknown): obj is number;
-declare function check_hex_digit(obj: unknown): obj is HexDigit;
-declare function get_hex_part(string: string): string;
-declare function check_hex(obj: unknown): obj is HexLike;
-declare function check_string(obj: unknown): obj is string;
-declare function check_array<T>(obj: unknown, predicate?: Predicate<T>, requiredLength?: number): obj is Array<T>;
-declare function check_number_array(obj: unknown, requiredLength?: number): obj is Array<number>;
-declare function check_string_array(obj: unknown, requiredLength?: number): obj is Array<string>;
-declare function has_property<Obj, Name extends string, Type extends JavaScriptTypes>(obj: Obj, name: Name, type: Type): obj is Obj & {
-    [name in Name]: JavaScriptTypeMap[Type];
-};
-
-declare const DJB2_OFFSET = 5381n;
-declare function djb2<V>(value: V): bigint;
-declare const FNV1_OFFSET = 14695981039346656037n;
-declare const FNV1_PRIME = 1099511628211n;
-declare function fnv1<V>(value: V): bigint;
-declare function sdbm<V>(value: V): bigint;
-interface IHash {
-    update(input: Uint8Array): this;
-    digest(): Uint8Array;
-}
-
-declare class MD2 implements IHash {
-    static readonly BLOCK_SIZE = 16;
-    private _data;
-    private _state;
-    private _checksum;
-    private _length;
-    constructor();
-    update(input: Uint8Array): this;
-    private _transform;
-    digest(): Uint8Array;
 }
 
-declare const MAX_ANGLE_DEGREE = 360;
-declare const cap_angle_degree: (angle: number) => number;
-declare const cap_angle_radian: (angle: number) => number;
-declare const radian_to_degree: (angle: number) => number;
-declare const degree_to_radian: (angle: number) => number;
-
 interface ICircle extends IVec2 {
     radius: number;
 }
+interface IToCircle {
+    toCircle(): CircleLike;
+}
 type CircleArray = [...Vec2Array, number];
 type CircleString = `${Vec2String}|${number}`;
-type CircleLike = ICircle | CircleArray | CircleString;
-declare class Circle implements ICircle, IGeometryObject, IToString {
+type CircleLike = ICircle | CircleArray | CircleString | IToCircle;
+type CircleArguments = [circle: CircleLike] | [position: Vec2Like, radius: number] | CircleArray;
+declare class Circle implements ICircle, IGeometryObject, IToVec2 {
     radius: number;
     get perimeter(): number;
     get area(): number;
@@ -301,24 +60,37 @@ declare class Circle implements ICircle, IGeometryObject, IToString {
     get w(): number;
     set w(val: number);
     static resolve(a: unknown): Circle;
+    static resolveArgs(args: CircleArguments): Circle;
     static cast(a: unknown): Circle | undefined;
     static is(a: unknown): a is CircleLike;
     constructor(position: Vec2Like, radius: number);
     toArray(): CircleArray;
     toJSON(): ICircle;
     toString(): CircleString;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     clone(): Circle;
+    toVec2(): Vec2Like;
     equals(circle: CircleLike): boolean;
-    inside(a: CircleLike): boolean;
-    insidePoint(a: Vec2Like): boolean;
+    equals(x: number, y: number, radius: number): boolean;
+    equals(position: Vec2Like, radius: number): boolean;
+    inside(circle: CircleLike): boolean;
+    inside(x: number, y: number, radius: number): boolean;
+    inside(position: Vec2Like, radius: number): boolean;
+    insidePoint(point: Vec2Like): boolean;
+    insidePoint(x: number, y: number): boolean;
 }
 
 interface IRectangle extends IVec2, ISize {
 }
+interface IToRectangle {
+    toRectangle(): RectangleLike;
+}
 type RectangleArray = [...Vec2Array, ...SizeArray];
 type RectangleString = `${Vec2String}|${SizeString}`;
-type RectangleLike = IRectangle | RectangleArray | RectangleString;
-declare class Rectangle implements IRectangle, IGeometryObject, IToString {
+type RectangleLike = IRectangle | RectangleArray | RectangleString | IToRectangle;
+type RectangleArguments = [rectangle: RectangleLike] | [position: Vec2Like, size: SizeLike] | RectangleArray;
+declare class Rectangle implements IRectangle, IGeometryObject, IToBoundingBox, IToVec2, IToSize {
     position: Vec2;
     size: Size;
     get area(): number;
@@ -334,15 +106,22 @@ declare class Rectangle implements IRectangle, IGeometryObject, IToString {
     get height(): number;
     set height(val: number);
     static resolve(a: unknown): Rectangle;
+    static resolveArgs(args: RectangleArguments): Rectangle;
     static cast(a: unknown): Rectangle | undefined;
     static is(a: unknown): a is RectangleLike;
     constructor(pos: Vec2Like, size: SizeLike);
     toArray(w?: boolean): RectangleArray;
     toString(w?: boolean): RectangleString;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     toJSON(): IRectangle;
     toBoundingBox(): BoundingBoxLike;
+    toVec2(): Vec2Like;
+    toSize(): SizeLike;
     clone(): Rectangle;
     equals(rectangle: RectangleLike): boolean;
+    equals(position: Vec2Like, size: SizeLike): boolean;
+    equals(x: number, y: number, width: number, height: number): boolean;
 }
 
 interface IBoundingBox {
@@ -351,10 +130,14 @@ interface IBoundingBox {
     top: number;
     bottom: number;
 }
+interface IToBoundingBox {
+    toBoundingBox(): BoundingBoxLike;
+}
 type BoundingBoxArray = [number, number, number, number];
 type BoundingBoxString = `${number},${number},${number},${number}`;
-type BoundingBoxLike = IBoundingBox | BoundingBoxArray | BoundingBoxString;
-declare class BoundingBox implements IBoundingBox, ISize, IToString {
+type BoundingBoxLike = IBoundingBox | BoundingBoxArray | BoundingBoxString | IToBoundingBox;
+type BoundingBoxArgs = [bbox: BoundingBoxLike] | BoundingBoxArray;
+declare class BoundingBox implements IBoundingBox, IRectangle, IToRectangle, IToString {
     left: number;
     right: number;
     top: number;
@@ -363,59 +146,34 @@ declare class BoundingBox implements IBoundingBox, ISize, IToString {
     set width(val: number);
     get height(): number;
     set height(val: number);
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    w: number;
     static resolve(a: unknown): BoundingBox;
+    static resolveArgs(args: BoundingBoxArgs): BoundingBox;
     static cast(a: unknown): BoundingBox | undefined;
     static is(a: unknown): a is BoundingBoxLike;
     constructor(left: number, right: number, top: number, bottom: number);
     toArray(): BoundingBoxArray;
     toString(): BoundingBoxString;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     toJSON(): IBoundingBox;
     clone(): BoundingBox;
     equals(bbox: BoundingBoxLike): boolean;
-    toSquare(): Size;
-    toRectangle(): Rectangle;
-    inside(a: BoundingBoxLike): boolean;
-    insidePoint(a: Vec2Like): boolean;
-    insideCircle(a: CircleLike): boolean;
-}
-
-interface ITriangle extends IGeometryObject {
-    readonly a: number;
-    readonly b: number;
-    readonly c: number;
-    readonly alpha: number;
-    readonly beta: number;
-    readonly gamma: number;
-    readonly semiperimeter: number;
-    readonly height: number;
-    readonly base: number;
-}
-declare abstract class ATriangle<P extends Vec2 | Vec3> implements ITriangle, IToString {
-    A: P;
-    B: P;
-    C: P;
-    abstract get a(): number;
-    abstract get b(): number;
-    abstract get c(): number;
-    constructor(A: P, B: P, C: P);
-    get alpha(): number;
-    get beta(): number;
-    get gamma(): number;
-    get perimeter(): number;
-    get semiperimeter(): number;
-    get area(): number;
-    get base(): number;
-    get height(): number;
-}
-declare class Triangle2D extends ATriangle<Vec2> implements IToString {
-    get a(): number;
-    get b(): number;
-    get c(): number;
-}
-declare class Triangle3D extends ATriangle<Vec3> {
-    get a(): number;
-    get b(): number;
-    get c(): number;
+    equals(left: number, right: number, top: number, bottom: number): boolean;
+    toSize(): SizeLike;
+    toVec2(): Vec2Like;
+    toRectangle(): RectangleLike;
+    inside(bbox: BoundingBoxLike): boolean;
+    inside(left: number, right: number, top: number, bottom: number): boolean;
+    insidePoint(point: Vec2Like): boolean;
+    insidePoint(x: number, y: number): boolean;
+    insideCircle(circle: CircleLike): boolean;
+    insideCircle(x: number, y: number, radius: number): boolean;
+    insideCircle(position: Vec2Like, radius: number): boolean;
 }
 
 interface IMat4 {
@@ -436,11 +194,15 @@ interface IMat4 {
     m32: number;
     m33: number;
 }
-type Mat4Array = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+interface IToMat4 {
+    toMat4(): Mat4Like;
+}
+type Mat4Array = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
 type Mat4NestedArray = [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]];
 type Mat4String = `${number},${number},${number},${number},${number},${number},${number},${number},${number},${number},${number},${number},${number},${number},${number},${number}`;
-type Mat4Like = IMat4 | Mat4Array | Mat4NestedArray | Mat4String | number;
-declare class Mat4 implements IMat4 {
+type Mat4Like = IMat4 | Mat4Array | Mat4NestedArray | Mat4String | number | IToMat4;
+type Mat4Arguments = [mat: Mat4Like] | Mat4Array;
+declare class Mat4 implements IMat4, IToMat3, IToString {
     protected _raw: Mat4Array;
     get m00(): number;
     set m00(val: number);
@@ -475,9 +237,11 @@ declare class Mat4 implements IMat4 {
     get m33(): number;
     set m33(val: number);
     static resolve(a: unknown): Mat4;
+    static resolveArgs(args: Mat4Arguments): Mat4;
     static cast(a: unknown): Mat4 | undefined;
     static is(a: unknown): a is Mat4Like;
     static orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+    static orthographic(bbox: BoundingBoxLike, near: number, far: number): Mat4;
     static perspective(fov: number, aspect: number, near: number, far: number): Mat4;
     static pointAt(position: Vec3Like, target: Vec3Like, up: Vec3Like): Mat4;
     constructor(init?: Mat4Array);
@@ -485,22 +249,28 @@ declare class Mat4 implements IMat4 {
     toNestetArray(): Mat4NestedArray;
     toJSON(): IMat4;
     toString(): Mat4String;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     clone(): Mat4;
     equals(mat: Mat4Like): boolean;
+    equals(...mat: Mat4Array): boolean;
     add(mat: Mat4Like): Mat4;
+    add(...mat: Mat4Array): Mat4;
     subtract(mat: Mat4Like): Mat4;
+    subtract(...mat: Mat4Array): Mat4;
     multiply(mat: Mat4Like): Mat4;
+    multiply(...mat: Mat4Array): Mat4;
     multiply(scalar: number): Mat4;
     multiply(vec: Vec3Like): Vec3;
-    translate(x: number, y: number, z: number): this;
-    translate(vec: Vec3Like): this;
+    translate(x: number, y: number, z: number): Mat4;
+    translate(vec: Vec3Like): Mat4;
     rotateX(angle: number): Mat4;
     rotateY(angle: number): Mat4;
     rotateZ(angle: number): Mat4;
-    rotate(x: number, y: number, z: number): this;
-    rotate(vec: Vec3Like): this;
-    scale(x: number, y: number, z: number): this;
-    scale(vec: Vec3Like): this;
+    rotate(x: number, y: number, z: number): Mat4;
+    rotate(vec: Vec3Like): Mat4;
+    scale(x: number, y: number, z: number): Mat4;
+    scale(vec: Vec3Like): Mat4;
     inverse(): Mat4;
     toMat3(): Mat3Like;
 }
@@ -516,11 +286,15 @@ interface IMat3 {
     m21: number;
     m22: number;
 }
+interface IToMat3 {
+    toMat3(): Mat3Like;
+}
 type Mat3Array = [number, number, number, number, number, number, number, number, number];
 type Mat3NestedArray = [[number, number, number], [number, number, number], [number, number, number]];
 type Mat3String = `${number},${number},${number},${number},${number},${number},${number},${number},${number}`;
-type Mat3Like = IMat3 | Mat3Array | Mat3NestedArray | Mat3String | number;
-declare class Mat3 implements IMat3 {
+type Mat3Like = IMat3 | Mat3Array | Mat3NestedArray | Mat3String | number | IToMat3;
+type Mat3Arguments = [mat: Mat3Like] | Mat3Array;
+declare class Mat3 implements IMat3, IToMat4, IToString {
     protected _raw: Mat3Array;
     get m00(): number;
     set m00(val: number);
@@ -541,6 +315,7 @@ declare class Mat3 implements IMat3 {
     get m22(): number;
     set m22(val: number);
     static resolve(a: unknown): Mat3;
+    static resolveArgs(args: Mat3Arguments): Mat3;
     static cast(a: unknown): Mat3 | undefined;
     static is(a: unknown): a is Mat3Like;
     static projection(width: number, height: number): Mat3;
@@ -549,11 +324,17 @@ declare class Mat3 implements IMat3 {
     toNestetArray(): Mat3NestedArray;
     toJSON(): IMat3;
     toString(): Mat3String;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     clone(): Mat3;
     equals(mat: Mat3Like): boolean;
+    equals(...mat: Mat3Array): boolean;
     add(mat: Mat3Like): Mat3;
+    add(...mat: Mat3Array): Mat3;
     subtract(mat: Mat3Like): Mat3;
+    subtract(...mat: Mat3Array): Mat3;
     multiply(mat: Mat3Like): Mat3;
+    multiply(...mat: Mat3Array): Mat3;
     multiply(scalar: number): Mat3;
     translate(x: number, y: number): Mat3;
     translate(vec: Vec2Like): Mat3;
@@ -565,25 +346,98 @@ declare class Mat3 implements IMat3 {
     toMat4(): Mat4Like;
 }
 
+interface IQuaternion {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+}
+interface IToQuaternion {
+    toQuaternion(): QuaternionLike;
+}
+type QuaternionArray = [number, number, number, number];
+type QuaternionString = `${number} + ${number}i + ${number}j + ${number}k`;
+type QuaternionLike = IQuaternion | QuaternionArray | QuaternionString | IToQuaternion;
+type QuaternionArguments = QuaternionArray | [quaternion: QuaternionLike];
+declare class Quaternion implements IToVec3, IToMat3, IToMat4, IToString {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+    static is(a: unknown): a is IQuaternion;
+    static resolve(a: unknown): Quaternion;
+    static resolveArgs(args: QuaternionArguments): Quaternion;
+    static cast(a: unknown): Quaternion | undefined;
+    static fromAxisAngle(axis: Vec3Like, angle: number): Quaternion;
+    static fromAxisAngle(x: number, y: number, z: number, angle: number): Quaternion;
+    static fromEuler(x: number, y: number, z: number): Quaternion;
+    static fromEuler(vec: Vec3Like): Quaternion;
+    static get zero(): Quaternion;
+    constructor(w: number, x: number, y: number, z: number);
+    toArray(): QuaternionArray;
+    toString(): QuaternionString;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+    toJSON(): IQuaternion;
+    clone(): Quaternion;
+    add(quaternion: QuaternionLike): Quaternion;
+    add(...quaternion: QuaternionArray): Quaternion;
+    offset(quaternion: QuaternionLike): this;
+    offset(...quaternion: QuaternionArray): this;
+    subtract(quaternion: QuaternionLike): Quaternion;
+    subtract(...quaternion: QuaternionArray): Quaternion;
+    negative(): Quaternion;
+    length(sqrt?: boolean): number;
+    normalize(): Quaternion;
+    multiply(quaternion: QuaternionLike): Quaternion;
+    multiply(...quaternion: QuaternionArray): Quaternion;
+    multiplyVector(x: number, y: number, z: number): Vec3;
+    multiplyVector(vec: Vec3Like): Vec3;
+    scale(scalar: number): Quaternion;
+    dot(quaternion: QuaternionLike): number;
+    dot(...quaternion: QuaternionArray): number;
+    inverse(): Quaternion;
+    divide(quaternion: QuaternionLike): Quaternion;
+    divide(...quaternion: QuaternionArray): Quaternion;
+    conjugate(): Quaternion;
+    exp(): Quaternion;
+    log(): Quaternion;
+    toVec3(): Vec3Like;
+    toAxisAngle(): Vec3;
+    toEuler(): Vec3;
+    toMat3(): Mat3Like;
+    toMat4(): Mat4Like;
+}
+
 interface IRGB {
     red: number;
     green: number;
     blue: number;
 }
+interface IToRGB {
+    toRGB(): RGBLike;
+}
 type RGBArray = [number, number, number];
 type RGBString = `rgb(${number},${number},${number})`;
-type RGBLike = IRGB | RGBArray | RGBString;
+type RGBLike = IRGB | RGBArray | RGBString | IToRGB;
+type RGBArguments = [rgb: RGBLike] | RGBArray;
 interface IRBBA extends IRGB {
     alpha: number;
 }
+interface IToRGBA {
+    toRGBA(): RGBALike;
+}
 type RGBAArray = [number, number, number, number];
 type RGBAString = `rgba(${number},${number},${number},${number})`;
-type RGBALike = IRBBA | RGBAArray | RGBAString;
+type RGBALike = IRBBA | RGBAArray | RGBAString | IToRGBA;
+type RGBAArguments = [rgba: RGBALike] | RGBAArray;
 type IAnyRGB = IRGB | IRBBA;
 type AnyRGBArray = RGBArray | RGBAArray;
 type AnyRGBString = RGBString | RGBAString;
-type AnyRGBLike = IAnyRGB | AnyRGBArray | AnyRGBString | HexLike | number;
-declare class RGBAColor implements IRBBA {
+type IAnyToRGB = IToRGB | IToRGBA;
+type AnyRGBLike = IAnyRGB | AnyRGBArray | AnyRGBString | number | IAnyToRGB;
+type AnyRGBArguments = RGBArguments | RGBAArguments;
+declare class RGBA implements IRBBA, IToVec2, IToVec3, IToHSL, IToHSLA, IToString {
     private _red;
     get red(): number;
     set red(val: number);
@@ -596,35 +450,53 @@ declare class RGBAColor implements IRBBA {
     private _alpha;
     get alpha(): number;
     set alpha(val: number);
-    static resolve(a: unknown): RGBAColor;
-    static cast(a: unknown): RGBAColor | undefined;
+    static resolve(a: unknown): RGBA;
+    static resolveArgs(args: AnyRGBArguments): RGBA;
+    static cast(a: unknown): RGBA | undefined;
     static is(a: unknown): a is AnyRGBLike;
     constructor(red: number, green: number, blue: number, alpha?: number);
     toArray(withAlpha?: boolean): AnyRGBArray;
     toJSON(withAlpha?: boolean): IAnyRGB;
     toString(withAlpha?: boolean): AnyRGBString;
-    toHSL(withAlpha?: boolean): HSLColor;
-    invert(withAlpha?: boolean): RGBAColor;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+    toVec2(): Vec2Like;
+    toVec3(): Vec3Like;
+    toHSL(withAlpha?: false): HSLLike;
+    toHSL(withAlpha?: true): HSLALike;
+    toHSLA(): HSLALike;
+    invert(withAlpha?: boolean): RGBA;
 }
+
 interface IHSL {
     hue: number;
     saturation: number;
     luminace: number;
 }
+interface IToHSL {
+    toHSL(): HSLLike;
+}
 type HSLArray = [number, number, number];
 type HSLString = `hsl(${number},${number},${number})`;
-type HSLLike = IHSL | HSLArray | HSLString;
+type HSLLike = IHSL | HSLArray | HSLString | IToHSL;
+type HSLArguments = HSLArray | [hsl: HSLLike];
 interface IHSLA extends IHSL {
     alpha: number;
 }
+interface IToHSLA {
+    toHSLA(): HSLALike;
+}
 type HSLAArray = [number, number, number, number];
 type HSLAString = `hsla(${number},${number},${number},${number})`;
-type HSLALike = IHSLA | HSLAArray | HSLAString;
+type HSLALike = IHSLA | HSLAArray | HSLAString | IToHSLA;
+type HSLAArguments = HSLAArray | [hsla: HSLALike];
 type IAnyHSL = IHSL | IHSLA;
 type AnyHSLArray = HSLArray | HSLAArray;
 type AnyHSLString = HSLString | HSLAString;
-type AnyHSLLike = IAnyHSL | AnyHSLArray | AnyHSLString | HexLike | number;
-declare class HSLColor implements IHSLA {
+type IAnyToHSL = IToHSL | IToHSLA;
+type AnyHSLLike = IAnyHSL | AnyHSLArray | AnyHSLString | number | IAnyToHSL;
+type AnyHSLArguments = HSLArguments | HSLAArguments;
+declare class HSLA implements IHSLA, IToRGB, IToRGBA, IToVec2, IToVec3, IToString {
     private _hue;
     get hue(): number;
     set hue(val: number);
@@ -637,100 +509,420 @@ declare class HSLColor implements IHSLA {
     private _alpha;
     get alpha(): number;
     set alpha(val: number);
-    static resolve(a: unknown): HSLColor;
-    static cast(a: unknown): HSLColor | undefined;
-    static is(a: unknown): boolean;
+    static resolve(a: unknown): HSLA;
+    static resolveArgs(args: AnyHSLArguments): HSLA;
+    static cast(a: unknown): HSLA | undefined;
+    static is(a: unknown): a is AnyHSLLike;
     constructor(hue: number, saturation: number, luminace: number, alpha?: number);
     toArray(withAlpha?: boolean): AnyHSLArray;
     toJSON(withAlpha?: boolean): IAnyHSL;
     toString(withAlpha?: boolean): AnyHSLString;
-    toRGB(withAlpha?: boolean): RGBAColor;
-    invert(withAlpha?: boolean): HSLColor;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+    toRGB(withAlpha?: true): RGBALike;
+    toRGB(withAlpha?: false): RGBLike;
+    toRGBA(): RGBALike;
+    toVec2(): Vec2Like;
+    toVec3(): Vec3Like;
+    invert(withAlpha?: boolean): HSLA;
 }
-type AnyColor = RGBAColor | HSLColor;
-type AnyColorArray = AnyRGBArray | AnyHSLArray;
-type AnyColorString = AnyRGBString | AnyHSLString;
-type IColor = IAnyRGB | IAnyHSL;
-type AnyColorLike = AnyColorArray | AnyColorString | IColor | HexLike | number;
-declare function resolveColor(a: unknown, preferHSL?: boolean): AnyColor;
-declare function castColor(a: unknown, preferHSL?: boolean): AnyColor | undefined;
 
-interface IQuaternion {
-    w: number;
+interface IVec3 extends IVec2 {
+    z: number;
+}
+interface IToVec3 {
+    toVec3(): Vec3Like;
+}
+type Vec3Array = [number, number, number] | [number, number, number, number];
+type Vec3String = `${number},${number},${number}` | `${number},${number},${number};${number}`;
+type Vec3Like = IVec3 | Vec3Array | Vec3String | number | IToVec3;
+type Vec3Arguments = [Vec3Like] | [number, number, number];
+declare class Vec3 implements IVec3, IToVec2, IToRGB, IToRGBA, IToHSL, IToHSLA, IToQuaternion, IToString {
     x: number;
     y: number;
     z: number;
+    w: number;
+    static resolve(a: unknown): Vec3;
+    static cast(a: unknown): Vec3 | undefined;
+    static resolveArgs(args: Vec3Arguments): Vec3;
+    static is(a: unknown): a is Vec3Like;
+    static fromPoints(a: Vec3Like, b: Vec3Like): Vec3;
+    static clamp(value: Vec3Like, min: Vec3Like, max: Vec3Like): Vec3;
+    static intersectPlane(planeP: Vec3Like, planeN: Vec3Like, lineStart: Vec3Like, lineEnd: Vec3Like, t: number): Vec3;
+    static get zero(): Vec3;
+    static get one(): Vec3;
+    constructor(x: number, y: number, z: number, w?: number);
+    toArray(w?: boolean): Vec3Array;
+    toJSON(): IVec3;
+    toString(w?: boolean): Vec3String;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+    toVec2(): Vec2Like;
+    toRGB(): RGBLike;
+    toRGBA(): RGBALike;
+    toHSL(): HSLLike;
+    toHSLA(): HSLALike;
+    toQuaternion(): QuaternionLike;
+    clone(): Vec3;
+    equals(vec: Vec3Like): boolean;
+    equals(x: number, y: number, z: number): boolean;
+    setX(x: number): this;
+    setY(y: number): this;
+    setZ(z: number): this;
+    set(x: number, y: number, z: number): this;
+    set(vec: Vec3Like): this;
+    add(x: number, y: number, z: number): Vec3;
+    add(vec: Vec3Like): Vec3;
+    offset(x: number, y: number, z: number): this;
+    offset(vec: Vec3Like): this;
+    subtract(x: number, y: number, z: number): Vec3;
+    subtract(vec: Vec3Like): Vec3;
+    multiply(scalar: number): Vec3;
+    naiveMultiply(x: number, y: number, z: number): Vec3;
+    naiveMultiply(vec: Vec3Like): Vec3;
+    divide(x: number, y: number, z: number): Vec3;
+    divide(scalar: number): Vec3;
+    divide(vec: Vec3Like): Vec3;
+    dot(x: number, y: number, z: number): number;
+    dot(vec: Vec3Like): number;
+    cross(x: number, y: number, z: number): Vec3;
+    cross(vec: Vec3Like): Vec3;
+    distance(x: number, y: number, z: number): number;
+    distance(vec: Vec3Like): number;
+    distanceSquare(x: number, y: number, z: number): number;
+    distanceSquare(vec: Vec3Like): number;
+    length(): number;
+    normalize(): Vec3;
+    invert(): Vec3;
+    round(): Vec3;
 }
-type QuaternionArray = [number, number, number, number];
-type QuaternionString = `${number} + ${number}i + ${number}j + ${number}k`;
-type QuaternionLike = IQuaternion | QuaternionArray | QuaternionString;
-declare class Quaternion {
+
+interface IVec2 {
+    x: number;
+    y: number;
     w: number;
+}
+interface IToVec2 {
+    toVec2(): Vec2Like;
+}
+type Vec2Array = [number, number] | [number, number, number];
+type Vec2String = `${number},${number}` | `${number},${number};${number}`;
+type Vec2Like = IVec2 | Vec2Array | Vec2String | number | IToVec2;
+type Vec2Arguments = [Vec2Like] | [number, number];
+declare class Vec2 implements IVec2, IToVec3, IToSize, IToRGB, IToRGBA, IToHSL, IToHSLA, IToString {
     x: number;
     y: number;
-    z: number;
-    static is(a: unknown): a is IQuaternion;
-    static resolve(a: unknown): Quaternion;
-    static cast(a: unknown): Quaternion | undefined;
-    static fromAxisAngle(axis: Vec3Like, angle: number): Quaternion;
-    static fromEuler(x: number, y: number, z: number): Quaternion;
-    static fromEuler(vec: Vec3Like): Quaternion;
-    constructor(w?: number, x?: number, y?: number, z?: number);
-    toArray(): QuaternionArray;
-    toString(): QuaternionString;
-    toJSON(): IQuaternion;
-    clone(): Quaternion;
-    add(a: QuaternionLike): Quaternion;
-    offset(a: QuaternionLike): this;
-    subtract(a: QuaternionLike): Quaternion;
-    negative(): Quaternion;
-    length(sqrt?: boolean): number;
-    normalize(): Quaternion;
-    multiply(a: QuaternionLike): Quaternion;
-    multiplyVector(x: number, y: number, z: number): Vec3;
-    multiplyVector(vec: Vec3Like): Vec3;
-    scale(scalar: number): Quaternion;
-    dot(a: QuaternionLike): number;
-    inverse(): Quaternion;
-    divide(a: QuaternionLike): Quaternion;
-    conjugate(): Quaternion;
-    exp(): Quaternion;
-    log(): Quaternion;
-    toVector(): Vec3;
-    toAxisAngle(): Vec3;
-    toEuler(): Vec3;
-    toMat3(): Mat3;
-    toMat4(): Mat4;
+    w: number;
+    static resolve(a: unknown): Vec2;
+    static cast(a: unknown): Vec2 | undefined;
+    static resolveArgs(args: Vec2Arguments): Vec2;
+    static is(a: unknown): a is Vec2Like;
+    static fromPoints(a: Vec2Like, b: Vec2Like): Vec2;
+    static clamp(value: Vec2Like, min: Vec2Like, max: Vec2Like): Vec2;
+    static get zero(): Vec2;
+    static get one(): Vec2;
+    constructor(x: number, y: number, w?: number);
+    toArray(w?: boolean): Vec2Array;
+    toJSON(): IVec2;
+    toString(w?: boolean): Vec2String;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+    toSize(): SizeLike;
+    toVec3(z?: number): Vec3Like;
+    toRGB(): RGBLike;
+    toRGBA(): RGBALike;
+    toHSL(): HSLLike;
+    toHSLA(): HSLALike;
+    clone(): Vec2;
+    equals(vec: Vec2Like): boolean;
+    equals(x: number, y: number): boolean;
+    setX(x: number): this;
+    setY(y: number): this;
+    setW(w: number): this;
+    set(x: number, y: number): this;
+    set(vec: Vec2Like): this;
+    add(x: number, y: number): Vec2;
+    add(vec: Vec2Like): Vec2;
+    offset(x: number, y: number): this;
+    offset(vec: Vec2Like): this;
+    subtract(x: number, y: number): Vec2;
+    subtract(vec: Vec2Like): Vec2;
+    multiply(scalar: number): Vec2;
+    naiveMultiply(x: number, y: number): Vec2;
+    naiveMultiply(vec: Vec2Like): Vec2;
+    divide(x: number, y: number): Vec2;
+    divide(scalar: number): Vec2;
+    divide(vec: Vec2Like): Vec2;
+    dot(x: number, y: number): number;
+    dot(vec: Vec2Like): number;
+    distance(x: number, y: number): number;
+    distance(vec: Vec2Like): number;
+    distanceSquare(x: number, y: number): number;
+    distanceSquare(vec: Vec2Like): number;
+    length(): number;
+    cartesianify(): Vec2;
+    polarify(): Vec2;
+    normalize(): Vec2;
+    invert(): Vec2;
+    round(): Vec2;
+}
+
+/**
+ * An abstract class of a mathematical function
+ * @template Input The amount of input values the function can use
+ */
+declare abstract class MathFunction<Input extends Array<number> = Array<number>> implements IToString {
+    /**
+     * Calculate y with input values
+     * @param args The input values
+     * @returns The y value from the input values
+     */
+    abstract get(...args: Input): number;
+    /**
+     * Get the root points of this function
+     * @returns The root points, this can be an empty array if no root points have been found
+     */
+    abstract roots(): Array<Vec2>;
+    abstract get [Symbol.toStringTag](): string;
+    abstract [NodeJSCustomInspect](): string;
+}
+
+/**
+ * The string representation of a linear function
+ */
+type LinearFunctionString = `f(x) = ${number} * x ${"+" | "-"} ${number}` | `f(x) = ${number} * x`;
+/**
+ * A class that implements a linear function with `m`, `b` and `x`
+ */
+declare class LinearFunction extends MathFunction<[number]> {
+    /**
+     * The factor of the linear function
+     */
+    m: number;
+    /**
+     * The height of the linear function
+     */
+    b: number;
+    /**
+     * Create a linear function from two points
+     * @param a A point
+     * @param b A point
+     * @returns A linear function from two points
+     */
+    static fromPoints(a: Vec2Like, b: Vec2Like): LinearFunction;
+    /**
+     * Create a linear function with a factor and height
+     * @param m The factor
+     * @param b The height
+     */
+    constructor(m: number, b: number);
+    get(x: number): number;
+    roots(): Array<Vec2>;
+    toString(): LinearFunctionString;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+}
+
+/**
+ * A type that represents the sign of a number
+ */
+type SignCharacter = "-" | "+";
+/**
+ * Get the sign character from a number
+ * @param num A number
+ */
+declare function signCharacter(num: number | bigint): SignCharacter | undefined;
+
+/**
+ * The various types of how a quad function can be represented
+ */
+type QuadFunctionType = "standard";
+/**
+ * A typed map of each quad function representations
+ */
+type QuadFunctionString = {
+    "standard": `f(x) = ${number}x^2 ${SignCharacter} ${number}x ${SignCharacter} ${number}` | `f(x) = ${number}x^2 ${SignCharacter} ${number}x` | `f(x) = ${number}x^2`;
+};
+/**
+ * A string representation of a quad function
+ */
+type QuadFunctionStrings = QuadFunctionString[QuadFunctionType];
+/**
+ * A class that implements a quad function with `a`, `b` and `c`
+ */
+declare class QuadFunction extends MathFunction<[number]> {
+    a: number;
+    b: number;
+    c: number;
+    static get(a: number, b: number, c: number, x: number): number;
+    constructor(a: number, b: number, c: number);
+    get(x: number): number;
+    roots(): Array<Vec2>;
+    toString<T extends QuadFunctionType>(type?: T): QuadFunctionString[T];
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
 }
 
+declare function numberToRGB(number: number): FixedArray<number, 3>;
+declare function numberToRGBA(number: number): FixedArray<number, 4>;
+
+/**
+ * A error when a value wasn't able to be resolved to another type
+ */
+declare class ResolveError extends Error {
+    readonly target: string;
+    readonly value: unknown;
+    /**
+     * Create a resolve exception
+     * @param target The target type name
+     * @param value A value
+     */
+    constructor(target: string, value: unknown);
+}
+
+declare const DJB2_OFFSET = 5381n;
+declare function djb2<V>(value: V): bigint;
+declare const FNV1_OFFSET = 14695981039346656037n;
+declare const FNV1_PRIME = 1099511628211n;
+declare function fnv1<V>(value: V): bigint;
+declare function sdbm<V>(value: V): bigint;
+interface IHash extends IToString {
+    update(input: Uint8Array): this;
+    digest(): Uint8Array;
+}
+
+declare class MD2 implements IHash {
+    static readonly BLOCK_SIZE = 16;
+    private _data;
+    private _state;
+    private _checksum;
+    private _length;
+    constructor();
+    update(input: Uint8Array): this;
+    private _transform;
+    digest(): Uint8Array;
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+}
+
+declare const MAX_ANGLE_DEGREE = 360;
+declare const clampAngleDegree: (angle: number) => number;
+declare const clampAngleRadian: (angle: number) => number;
+declare const radianToDegree: (angle: number) => number;
+declare const degreeToRadian: (angle: number) => number;
+
+interface ITriangle extends IGeometryObject {
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+    readonly alpha: number;
+    readonly beta: number;
+    readonly gamma: number;
+    readonly semiperimeter: number;
+    readonly height: number;
+    readonly base: number;
+}
+declare abstract class Triangle<T> implements ITriangle {
+    A: T;
+    B: T;
+    C: T;
+    abstract get a(): number;
+    abstract get b(): number;
+    abstract get c(): number;
+    constructor(A: T, B: T, C: T);
+    get alpha(): number;
+    get beta(): number;
+    get gamma(): number;
+    get perimeter(): number;
+    get semiperimeter(): number;
+    get area(): number;
+    get base(): number;
+    get height(): number;
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+}
+declare class Triangle2D extends Triangle<Vec2> {
+    get a(): number;
+    get b(): number;
+    get c(): number;
+}
+declare class Triangle3D extends Triangle<Vec3> {
+    get a(): number;
+    get b(): number;
+    get c(): number;
+}
+
+type AnyColorArray = AnyRGBArray | AnyHSLArray;
+type AnyColorString = AnyRGBString | AnyHSLString;
+type IAnyColor = IAnyRGB | IAnyHSL;
+type IAnyToColor = IAnyToRGB | IAnyToHSL;
+type AnyColorLike = AnyColorArray | AnyColorString | IAnyColor | number;
+type AnyColorArguments = AnyColorArray | [color: AnyColorLike];
+type AnyColor = RGBA | HSLA;
+declare namespace AnyColor {
+    function cast(a: unknown, preferHSL?: boolean): AnyColor | undefined;
+    function resolve(a: unknown, preferHSL?: boolean): AnyColor;
+    function resolveArgs(args: AnyColorArguments, preferHSL?: boolean): AnyColor;
+}
+
+declare class Transform2D implements IToMat3, IToString {
+    parent?: Transform2D | undefined;
+    origin: Vec2;
+    localPosition: Vec2;
+    localRotation: number;
+    get localRotationDegree(): number;
+    set localRotationDegree(v: number);
+    localScale: Vec2;
+    get globalPosition(): Vec2;
+    get globalRotation(): number;
+    get globalRotationDegree(): number;
+    get globalScale(): Vec2;
+    constructor(position: Vec2Like, rotation: number, scale: Vec2Like, parent?: Transform2D | undefined);
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+    toMat3(): Mat3;
+    toGlobalMat3(): Mat3;
+}
 /**
  * Represents a 3D transform for 3D graphics
  */
-declare class Transform {
+declare class Transform3D implements IToMat4, IToString {
+    parent?: Transform3D | undefined;
+    origin: Vec3;
     /**
-     * The position of the object
+     * The local position
      */
-    position: Vec3;
+    localPosition: Vec3;
     /**
-     * The rotation of the object
+     * The local rotation
      */
-    rotation: Quaternion;
+    localRotation: Quaternion;
     /**
-     * The scale of the object
+     * The local scale
      */
-    scale: Vec3;
+    localScale: Vec3;
+    get globalPosition(): Vec3;
+    get globalRotation(): Quaternion;
+    get globalScale(): Vec3;
     /**
      * Create a new transform with `position`, `rotation` and `scale`
      * @param position The position as a Vec3
      * @param rotation The rotation as a Quaternion
      * @param scale The scale as a Vec3
      */
-    constructor(position: Vec3Like, rotation: QuaternionLike, scale: Vec3Like);
+    constructor(position: Vec3Like, rotation: QuaternionLike, scale: Vec3Like, parent?: Transform3D | undefined);
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
     /**
      * Convert the transform into a 4x3 matrix
      * @returns A 4x4 matrix from the transform
      */
     toMat4(): Mat4;
+    toGlobalMat4(): Mat4;
 }
 
 /**
@@ -747,7 +939,8 @@ declare function clamp<T extends number | bigint>(value: T, min: T, max: T): T;
  * @param b The input value b
  * @returns The result
  */
-declare function log_hypot(a: number, b: number): number;
+declare function logHypot(a: number, b: number): number;
 declare const EPSILON = 1e-16;
+declare const lerp: <T extends number | bigint>(a: T, b: T, t: T) => number;
 
-export { ATriangle, type AnyColor, type AnyColorArray, type AnyColorLike, type AnyColorString, type AnyHSLArray, type AnyHSLLike, type AnyHSLString, type AnyRGBArray, type AnyRGBLike, type AnyRGBString, BoundingBox, type BoundingBoxArray, type BoundingBoxLike, type BoundingBoxString, Circle, type CircleArray, type CircleLike, type CircleString, DJB2_OFFSET, EPSILON, FNV1_OFFSET, FNV1_PRIME, type HSLAArray, type HSLALike, type HSLAString, type HSLArray, HSLColor, type HSLLike, type HSLString, type HexDigit, type HexLike, type IAnyHSL, type IAnyRGB, type IBoundingBox, type ICircle, type IColor, type IGeometryObject, type IHSL, type IHSLA, type IHash, type IMat3, type IMat4, type IQuaternion, type IRBBA, type IRGB, type IRectangle, type ISize, type IToString, type ITriangle, type IVec2, type IVec3, type JavaScriptTypeMap, type JavaScriptTypes, LinearFunction, type LinearFunctionString, MAX_ANGLE_DEGREE, MD2, Mat3, type Mat3Array, type Mat3Like, type Mat3NestedArray, type Mat3String, Mat4, type Mat4Array, type Mat4Like, type Mat4NestedArray, type Mat4String, MathFunction, type Predicate, QuadFunction, type QuadFunctionString, type QuadFunctionStrings, type QuadFunctionType, Quaternion, type QuaternionArray, type QuaternionLike, type QuaternionString, type RGBAArray, RGBAColor, type RGBALike, type RGBAString, type RGBArray, type RGBLike, type RGBString, Rectangle, type RectangleArray, type RectangleLike, type RectangleString, ResolveError, Size, type SizeArguments, type SizeArray, type SizeLike, type SizeString, Transform, Triangle2D, Triangle3D, Vec2, type Vec2Arguments, type Vec2Array, type Vec2Like, type Vec2String, Vec3, type Vec3Arguments, type Vec3Array, type Vec3Like, type Vec3String, cap_angle_degree, cap_angle_radian, castColor, check_array, check_hex, check_hex_digit, check_number, check_number_array, check_string, check_string_array, clamp, degree_to_radian, djb2, fnv1, get_hex_part, has_property, log_hypot, radian_to_degree, resolveColor, sdbm, sign_char, stringify };
+export { AnyColor, type AnyColorArguments, type AnyColorArray, type AnyColorLike, type AnyColorString, type AnyHSLArguments, type AnyHSLArray, type AnyHSLLike, type AnyHSLString, type AnyRGBArguments, type AnyRGBArray, type AnyRGBLike, type AnyRGBString, BoundingBox, type BoundingBoxArgs, type BoundingBoxArray, type BoundingBoxLike, type BoundingBoxString, Circle, type CircleArguments, type CircleArray, type CircleLike, type CircleString, DJB2_OFFSET, EPSILON, FNV1_OFFSET, FNV1_PRIME, HSLA, type HSLAArguments, type HSLAArray, type HSLALike, type HSLAString, type HSLArguments, type HSLArray, type HSLLike, type HSLString, type IAnyColor, type IAnyHSL, type IAnyRGB, type IAnyToColor, type IAnyToHSL, type IAnyToRGB, type IBoundingBox, type ICircle, type IGeometryObject, type IHSL, type IHSLA, type IHash, type IMat3, type IMat4, type IQuaternion, type IRBBA, type IRGB, type IRectangle, type ISize, type IToBoundingBox, type IToCircle, type IToHSL, type IToHSLA, type IToMat3, type IToMat4, type IToQuaternion, type IToRGB, type IToRGBA, type IToRectangle, type IToSize, type IToVec2, type IToVec3, type ITriangle, type IVec2, type IVec3, LinearFunction, type LinearFunctionString, MAX_ANGLE_DEGREE, MD2, Mat3, type Mat3Arguments, type Mat3Array, type Mat3Like, type Mat3NestedArray, type Mat3String, Mat4, type Mat4Arguments, type Mat4Array, type Mat4Like, type Mat4NestedArray, type Mat4String, MathFunction, QuadFunction, type QuadFunctionString, type QuadFunctionStrings, type QuadFunctionType, Quaternion, type QuaternionArguments, type QuaternionArray, type QuaternionLike, type QuaternionString, RGBA, type RGBAArguments, type RGBAArray, type RGBALike, type RGBAString, type RGBArguments, type RGBArray, type RGBLike, type RGBString, Rectangle, type RectangleArguments, type RectangleArray, type RectangleLike, type RectangleString, ResolveError, type SignCharacter, Size, type SizeArguments, type SizeArray, type SizeLike, type SizeString, Transform2D, Transform3D, Triangle, Triangle2D, Triangle3D, Vec2, type Vec2Arguments, type Vec2Array, type Vec2Like, type Vec2String, Vec3, type Vec3Arguments, type Vec3Array, type Vec3Like, type Vec3String, clamp, clampAngleDegree, clampAngleRadian, degreeToRadian, djb2, fnv1, lerp, logHypot, numberToRGB, numberToRGBA, radianToDegree, sdbm, signCharacter };