@ntf/math 1.3.1 → 1.4.0

package/dist/index.d.ts

@@ -1,50 +1,650 @@
-declare function stringify<V>(value: V): string;
+/**
+ * All valid types of JavaScript you can get from `typeof`
+ */
+type JavaScriptTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+/**
+ * A JavaScript function that can be typed (or not)
+ */
+type JavaScriptFunction<Args extends Array<any> = Array<any>, ReturnType extends any = any> = (...args: Args) => ReturnType;
+/**
+ * A mapped type for getting the type of a JavaScript value
+ */
+type JavaScriptTypeMap = {
+    "string": string;
+    "number": number;
+    "bigint": bigint;
+    "boolean": boolean;
+    "symbol": symbol;
+    "undefined": undefined;
+    "object": object;
+    "function": JavaScriptFunction;
+};
+/**
+ * Any kind of JavaScript number
+ */
+type JavaScriptNumber = number | bigint;
+/**
+ * A array that has a fixed length
+ */
+type FixedArray<T, Length extends number> = Array<T> & {
+    length: Length;
+};
+/**
+ * A value that might look like a hex value
+ */
+type HexLike = `$${string}` | `#${string}` | `0x${string}` | string;
+/**
+ * A predicate function type for verifing types
+ */
+type Predicate<T> = (a: unknown) => a is T;
+/**
+ * Check if `value` is a finite valid number
+ * @param value A value
+ */
+declare function checkNumber(value: unknown): value is number;
+/**
+ * Retrieve the value of a hex string
+ * @param string A string
+ */
+declare function getHexValue(string: string): string;
+/**
+ * Check if `value` is a hex value
+ * @param value A value
+ */
+declare function checkHex(value: unknown): value is HexLike;
+/**
+ * Check if `value` is a string with content
+ * @param value A value
+ */
+declare function checkString(value: unknown): value is string;
+/**
+ * Check if `value` is a array
+ * @param value A value
+ * @param predicate A function that checks each item
+ * @param requiredLength If needed, check if it is a fixed length array
+ */
+declare function checkArray<T, Length extends number>(value: unknown, predicate?: Predicate<T>, requiredLength?: number): value is FixedArray<T, Length>;
+/**
+ * Check if `value` is a number array
+ * @param value A value
+ * @param requiredLength If needed, check if it is a fixed length array
+ */
+declare function checkNumberArray<Length extends number>(value: unknown, requiredLength?: Length): value is FixedArray<number, Length>;
+/**
+ * Check if `value` is a string array
+ * @param value A value
+ * @param requiredLength If needed, check if it is a fixed length array
+ */
+declare function checkStringArray<Length extends number>(value: unknown, requiredLength?: Length): value is FixedArray<string, Length>;
+/**
+ * Check if `value` has a property called `name`
+ * @param value A value
+ * @param propertyName The name of the property
+ * @param type
+ */
+declare function hasProperty<Obj extends unknown, K extends PropertyKey, T extends JavaScriptTypes>(value: Obj, propertyName: K, type: T): value is Obj & {
+    [name in K]: JavaScriptTypeMap[T];
+};
+declare const NodeJSCustomInspect: unique symbol;
+
 interface IToString {
     /**
      * Returns a string representation of an object.
      */
     toString(): string;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
+}
+
+interface IGeometryObject extends IToString {
+    readonly area: number;
+    readonly perimeter: number;
+}
+
+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 | 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(size: SizeLike): boolean;
+    equals(width: number, height: number): boolean;
+    toVec2(): Vec2Like;
+}
+
+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 | 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 | IToRGBA;
+type RGBAArguments = [rgba: RGBALike] | RGBAArray;
+type IAnyRGB = IRGB | IRBBA;
+type AnyRGBArray = RGBArray | RGBAArray;
+type AnyRGBString = RGBString | RGBAString;
+type IAnyToRGB = IToRGB | IToRGBA;
+type AnyRGBLike = IAnyRGB | AnyRGBArray | AnyRGBString | HexLike | 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);
+    private _green;
+    get green(): number;
+    set green(val: number);
+    private _blue;
+    get blue(): number;
+    set blue(val: number);
+    private _alpha;
+    get alpha(): number;
+    set alpha(val: number);
+    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;
+    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 | 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 | IToHSLA;
+type HSLAArguments = HSLAArray | [hsla: HSLALike];
+type IAnyHSL = IHSL | IHSLA;
+type AnyHSLArray = HSLArray | HSLAArray;
+type AnyHSLString = HSLString | HSLAString;
+type IAnyToHSL = IToHSL | IToHSLA;
+type AnyHSLLike = IAnyHSL | AnyHSLArray | AnyHSLString | HexLike | 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);
+    private _saturation;
+    get saturation(): number;
+    set saturation(val: number);
+    private _luminace;
+    get luminace(): number;
+    set luminace(val: number);
+    private _alpha;
+    get alpha(): number;
+    set alpha(val: number);
+    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;
+    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 AnyColorArray = AnyRGBArray | AnyHSLArray;
+type AnyColorString = AnyRGBString | AnyHSLString;
+type IAnyColor = IAnyRGB | IAnyHSL;
+type IAnyToColor = IAnyToRGB | IAnyToHSL;
+type AnyColorLike = AnyColorArray | AnyColorString | IAnyColor | HexLike | 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;
+}
+
+interface ICircle extends IVec2 {
+    radius: number;
+}
+interface IToCircle {
+    toCircle(): CircleLike;
+}
+type CircleArray = [...Vec2Array, number];
+type CircleString = `${Vec2String}|${number}`;
+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;
+    position: Vec2;
+    get x(): number;
+    set x(val: number);
+    get y(): number;
+    set y(val: number);
+    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;
+    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 | 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;
+    get perimeter(): number;
+    get x(): number;
+    set x(val: number);
+    get y(): number;
+    set y(val: number);
+    get w(): number;
+    set w(val: number);
+    get width(): number;
+    set width(val: number);
+    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 {
+    left: number;
+    right: number;
+    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 | IToBoundingBox;
+type BoundingBoxArgs = [bbox: BoundingBoxLike] | BoundingBoxArray;
+declare class BoundingBox implements IBoundingBox, IRectangle, IToRectangle, IToString {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    get width(): number;
+    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;
+    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 {
+    m00: number;
+    m01: number;
+    m02: number;
+    m03: number;
+    m10: number;
+    m11: number;
+    m12: number;
+    m13: number;
+    m20: number;
+    m21: number;
+    m22: number;
+    m23: number;
+    m30: number;
+    m31: number;
+    m32: number;
+    m33: 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 | IToMat4;
+type Mat4Arguments = [mat: Mat4Like] | Mat4Array;
+declare class Mat4 implements IMat4, IToMat3, IToString {
+    protected _raw: Mat4Array;
+    get m00(): number;
+    set m00(val: number);
+    get m01(): number;
+    set m01(val: number);
+    get m02(): number;
+    set m02(val: number);
+    get m03(): number;
+    set m03(val: number);
+    get m10(): number;
+    set m10(val: number);
+    get m11(): number;
+    set m11(val: number);
+    get m12(): number;
+    set m12(val: number);
+    get m13(): number;
+    set m13(val: number);
+    get m20(): number;
+    set m20(val: number);
+    get m21(): number;
+    set m21(val: number);
+    get m22(): number;
+    set m22(val: number);
+    get m23(): number;
+    set m23(val: number);
+    get m30(): number;
+    set m30(val: number);
+    get m31(): number;
+    set m31(val: number);
+    get m32(): number;
+    set m32(val: number);
+    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);
+    toArray(): Mat4Array;
+    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): Mat4;
+    translate(vec: Vec3Like): Mat4;
+    rotateX(angle: number): Mat4;
+    rotateY(angle: number): Mat4;
+    rotateZ(angle: number): Mat4;
+    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;
 }
 
-interface IGeometryObject {
-    readonly area: number;
-    readonly perimeter: number;
+interface IMat3 {
+    m00: number;
+    m01: number;
+    m02: number;
+    m10: number;
+    m11: number;
+    m12: number;
+    m20: number;
+    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 | IToMat3;
+type Mat3Arguments = [mat: Mat3Like] | Mat3Array;
+declare class Mat3 implements IMat3, IToMat4, IToString {
+    protected _raw: Mat3Array;
+    get m00(): number;
+    set m00(val: number);
+    get m01(): number;
+    set m01(val: number);
+    get m02(): number;
+    set m02(val: number);
+    get m10(): number;
+    set m10(val: number);
+    get m11(): number;
+    set m11(val: number);
+    get m12(): number;
+    set m12(val: number);
+    get m20(): number;
+    set m20(val: number);
+    get m21(): number;
+    set m21(val: number);
+    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;
+    constructor(init?: Mat3Array);
+    toArray(): Mat3Array;
+    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;
+    rotate(angle: number): Mat3;
+    scale(x: number, y: number): Mat3;
+    scale(vec: Vec2Like): Mat3;
+    determinant(): number;
+    inverse(): Mat3;
+    toMat4(): Mat4Like;
 }
 
-interface ISize {
-    width: number;
-    height: number;
+interface IQuaternion {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
 }
-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 {
-    width: number;
-    height: number;
-    get aspectRatio(): number;
-    get area(): number;
-    get perimeter(): number;
-    static resolve(a: unknown): Size;
-    static cast(a: unknown): Size | undefined;
-    static is(a: unknown): a is SizeLike;
-    constructor(width: number, height: number);
-    toArray(): SizeArray;
-    toString(): SizeString;
-    toJSON(): ISize;
-    clone(): Size;
-    equals(square: SizeLike): boolean;
-    toVec2(): Vec2Like;
+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 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;
+type Vec3Like = IVec3 | Vec3Array | Vec3String | number | IToVec3;
 type Vec3Arguments = [Vec3Like] | [number, number, number];
-declare class Vec3 implements IVec3 {
+declare class Vec3 implements IVec3, IToVec2, IToRGB, IToRGBA, IToHSL, IToHSLA, IToQuaternion, IToString {
     x: number;
     y: number;
     z: number;
@@ -56,13 +656,23 @@ declare class Vec3 implements IVec3 {
     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);
+    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;
@@ -99,11 +709,14 @@ interface IVec2 {
     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;
+type Vec2Like = IVec2 | Vec2Array | Vec2String | number | IToVec2;
 type Vec2Arguments = [Vec2Like] | [number, number];
-declare class Vec2 implements IVec2 {
+declare class Vec2 implements IVec2, IToVec3, IToSize, IToRGB, IToRGBA, IToHSL, IToHSLA, IToString {
     x: number;
     y: number;
     w: number;
@@ -113,14 +726,23 @@ declare class Vec2 implements IVec2 {
     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);
+    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;
-    toSquare(): Size;
-    toVec3(z?: number): Vec3;
+    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;
@@ -168,6 +790,8 @@ declare abstract class MathFunction<Input extends Array<number> = Array<number>>
      * @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;
 }
 
 /**
@@ -202,13 +826,37 @@ declare class LinearFunction extends MathFunction<[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 ${"+" | "-"} ${number}x ${"+" | "-"} ${number}` | `f(x) = ${number}x^2 ${"+" | "-"} ${number}x` | `f(x) = ${number}x^2`;
+    "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;
@@ -218,168 +866,56 @@ declare class QuadFunction extends MathFunction<[number]> {
     get(x: number): number;
     roots(): Array<Vec2>;
     toString<T extends QuadFunctionType>(type?: T): QuadFunctionString[T];
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
 }
 
+/**
+ * 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 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 {
+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;
-}
-
-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;
-}
-type CircleArray = [...Vec2Array, number];
-type CircleString = `${Vec2String}|${number}`;
-type CircleLike = ICircle | CircleArray | CircleString;
-declare class Circle implements ICircle, IGeometryObject, IToString {
-    radius: number;
-    get perimeter(): number;
-    get area(): number;
-    position: Vec2;
-    get x(): number;
-    set x(val: number);
-    get y(): number;
-    set y(val: number);
-    get w(): number;
-    set w(val: number);
-    static resolve(a: unknown): 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;
-    clone(): Circle;
-    equals(circle: CircleLike): boolean;
-    inside(a: CircleLike): boolean;
-    insidePoint(a: Vec2Like): boolean;
-}
-
-interface IRectangle extends IVec2, ISize {
-}
-type RectangleArray = [...Vec2Array, ...SizeArray];
-type RectangleString = `${Vec2String}|${SizeString}`;
-type RectangleLike = IRectangle | RectangleArray | RectangleString;
-declare class Rectangle implements IRectangle, IGeometryObject, IToString {
-    position: Vec2;
-    size: Size;
-    get area(): number;
-    get perimeter(): number;
-    get x(): number;
-    set x(val: number);
-    get y(): number;
-    set y(val: number);
-    get w(): number;
-    set w(val: number);
-    get width(): number;
-    set width(val: number);
-    get height(): number;
-    set height(val: number);
-    static resolve(a: unknown): Rectangle;
-    static cast(a: unknown): Rectangle | undefined;
-    static is(a: unknown): a is RectangleLike;
-    constructor(pos: Vec2Like, size: SizeLike);
-    constructor(x: number, y: number, width: number, height: number);
-    toArray(w?: boolean): RectangleArray;
-    toString(w?: boolean): RectangleString;
-    toJSON(): IRectangle;
-    toBoundingBox(): BoundingBoxLike;
-    clone(): Rectangle;
-    equals(rectangle: RectangleLike): boolean;
-}
-
-interface IBoundingBox {
-    left: number;
-    right: number;
-    top: number;
-    bottom: number;
-}
-type BoundingBoxArray = [number, number, number, number];
-type BoundingBoxString = `${number},${number},${number},${number}`;
-type BoundingBoxLike = IBoundingBox | BoundingBoxArray | BoundingBoxString;
-declare class BoundingBox implements IBoundingBox, ISize, IToString {
-    left: number;
-    right: number;
-    top: number;
-    bottom: number;
-    get width(): number;
-    set width(val: number);
-    get height(): number;
-    set height(val: number);
-    static resolve(a: unknown): 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;
-    toJSON(): IBoundingBox;
-    clone(): BoundingBox;
-    equals(bbox: BoundingBoxLike): boolean;
-    toSquare(): Size;
-    toRectangle(): Rectangle;
-    inside(a: BoundingBoxLike): boolean;
-    insidePoint(a: Vec2Like): boolean;
-    insideCircle(a: CircleLike): boolean;
+    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;
@@ -391,14 +927,14 @@ interface ITriangle extends IGeometryObject {
     readonly height: number;
     readonly base: number;
 }
-declare abstract class ATriangle<P extends Vec2 | Vec3> implements ITriangle, IToString {
-    A: P;
-    B: P;
-    C: P;
+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: P, B: P, C: P);
+    constructor(A: T, B: T, C: T);
     get alpha(): number;
     get beta(): number;
     get gamma(): number;
@@ -407,331 +943,77 @@ declare abstract class ATriangle<P extends Vec2 | Vec3> implements ITriangle, IT
     get area(): number;
     get base(): number;
     get height(): number;
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    [NodeJSCustomInspect](): string;
 }
-declare class Triangle2D extends ATriangle<Vec2> implements IToString {
+declare class Triangle2D extends Triangle<Vec2> {
     get a(): number;
     get b(): number;
     get c(): number;
 }
-declare class Triangle3D extends ATriangle<Vec3> {
+declare class Triangle3D extends Triangle<Vec3> {
     get a(): number;
     get b(): number;
     get c(): number;
 }
 
-interface IMat4 {
-    m00: number;
-    m01: number;
-    m02: number;
-    m03: number;
-    m10: number;
-    m11: number;
-    m12: number;
-    m13: number;
-    m20: number;
-    m21: number;
-    m22: number;
-    m23: number;
-    m30: number;
-    m31: number;
-    m32: number;
-    m33: number;
-}
-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 {
-    protected _raw: Mat4Array;
-    get m00(): number;
-    set m00(val: number);
-    get m01(): number;
-    set m01(val: number);
-    get m02(): number;
-    set m02(val: number);
-    get m03(): number;
-    set m03(val: number);
-    get m10(): number;
-    set m10(val: number);
-    get m11(): number;
-    set m11(val: number);
-    get m12(): number;
-    set m12(val: number);
-    get m13(): number;
-    set m13(val: number);
-    get m20(): number;
-    set m20(val: number);
-    get m21(): number;
-    set m21(val: number);
-    get m22(): number;
-    set m22(val: number);
-    get m23(): number;
-    set m23(val: number);
-    get m30(): number;
-    set m30(val: number);
-    get m31(): number;
-    set m31(val: number);
-    get m32(): number;
-    set m32(val: number);
-    get m33(): number;
-    set m33(val: number);
-    static resolve(a: unknown): 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 perspective(fov: number, aspect: number, near: number, far: number): Mat4;
-    static pointAt(position: Vec3Like, target: Vec3Like, up: Vec3Like): Mat4;
-    constructor(init?: Mat4Array);
-    toArray(): Mat4Array;
-    toNestetArray(): Mat4NestedArray;
-    toJSON(): IMat4;
-    toString(): Mat4String;
-    clone(): Mat4;
-    equals(mat: Mat4Like): boolean;
-    add(mat: Mat4Like): Mat4;
-    subtract(mat: Mat4Like): Mat4;
-    multiply(mat: Mat4Like): Mat4;
-    multiply(scalar: number): Mat4;
-    multiply(vec: Vec3Like): Vec3;
-    translate(x: number, y: number, z: number): this;
-    translate(vec: Vec3Like): this;
-    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;
-    inverse(): Mat4;
-    toMat3(): Mat3Like;
-}
-
-interface IMat3 {
-    m00: number;
-    m01: number;
-    m02: number;
-    m10: number;
-    m11: number;
-    m12: number;
-    m20: number;
-    m21: number;
-    m22: number;
-}
-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 {
-    protected _raw: Mat3Array;
-    get m00(): number;
-    set m00(val: number);
-    get m01(): number;
-    set m01(val: number);
-    get m02(): number;
-    set m02(val: number);
-    get m10(): number;
-    set m10(val: number);
-    get m11(): number;
-    set m11(val: number);
-    get m12(): number;
-    set m12(val: number);
-    get m20(): number;
-    set m20(val: number);
-    get m21(): number;
-    set m21(val: number);
-    get m22(): number;
-    set m22(val: number);
-    static resolve(a: unknown): Mat3;
-    static cast(a: unknown): Mat3 | undefined;
-    static is(a: unknown): a is Mat3Like;
-    static projection(width: number, height: number): Mat3;
-    constructor(init?: Mat3Array);
-    toArray(): Mat3Array;
-    toNestetArray(): Mat3NestedArray;
-    toJSON(): IMat3;
-    toString(): Mat3String;
-    clone(): Mat3;
-    equals(mat: Mat3Like): boolean;
-    add(mat: Mat3Like): Mat3;
-    subtract(mat: Mat3Like): Mat3;
-    multiply(mat: Mat3Like): Mat3;
-    multiply(scalar: number): Mat3;
-    translate(x: number, y: number): Mat3;
-    translate(vec: Vec2Like): Mat3;
-    rotate(angle: number): Mat3;
-    scale(x: number, y: number): Mat3;
-    scale(vec: Vec2Like): Mat3;
-    determinant(): number;
-    inverse(): Mat3;
-    toMat4(): Mat4Like;
-}
-
-interface IRGB {
-    red: number;
-    green: number;
-    blue: number;
-}
-type RGBArray = [number, number, number];
-type RGBString = `rgb(${number},${number},${number})`;
-type RGBLike = IRGB | RGBArray | RGBString;
-interface IRBBA extends IRGB {
-    alpha: number;
-}
-type RGBAArray = [number, number, number, number];
-type RGBAString = `rgba(${number},${number},${number},${number})`;
-type RGBALike = IRBBA | RGBAArray | RGBAString;
-type IAnyRGB = IRGB | IRBBA;
-type AnyRGBArray = RGBArray | RGBAArray;
-type AnyRGBString = RGBString | RGBAString;
-type AnyRGBLike = IAnyRGB | AnyRGBArray | AnyRGBString | HexLike | number;
-declare class RGBAColor implements IRBBA {
-    private _red;
-    get red(): number;
-    set red(val: number);
-    private _green;
-    get green(): number;
-    set green(val: number);
-    private _blue;
-    get blue(): number;
-    set blue(val: number);
-    private _alpha;
-    get alpha(): number;
-    set alpha(val: number);
-    static resolve(a: unknown): RGBAColor;
-    static cast(a: unknown): RGBAColor | 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;
-}
-interface IHSL {
-    hue: number;
-    saturation: number;
-    luminace: number;
-}
-type HSLArray = [number, number, number];
-type HSLString = `hsl(${number},${number},${number})`;
-type HSLLike = IHSL | HSLArray | HSLString;
-interface IHSLA extends IHSL {
-    alpha: number;
-}
-type HSLAArray = [number, number, number, number];
-type HSLAString = `hsla(${number},${number},${number},${number})`;
-type HSLALike = IHSLA | HSLAArray | HSLAString;
-type IAnyHSL = IHSL | IHSLA;
-type AnyHSLArray = HSLArray | HSLAArray;
-type AnyHSLString = HSLString | HSLAString;
-type AnyHSLLike = IAnyHSL | AnyHSLArray | AnyHSLString | HexLike | number;
-declare class HSLColor implements IHSLA {
-    private _hue;
-    get hue(): number;
-    set hue(val: number);
-    private _saturation;
-    get saturation(): number;
-    set saturation(val: number);
-    private _luminace;
-    get luminace(): number;
-    set luminace(val: number);
-    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;
-    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;
-}
-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;
-    x: number;
-    y: number;
-    z: number;
-}
-type QuaternionArray = [number, number, number, number];
-type QuaternionString = `${number} + ${number}i + ${number}j + ${number}k`;
-type QuaternionLike = IQuaternion | QuaternionArray | QuaternionString;
-declare class Quaternion {
-    w: number;
-    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;
+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;
-    toMat4(): Mat4;
+    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;
 }
 
 /**
@@ -748,7 +1030,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, type FixedArray, HSLA, type HSLAArguments, type HSLAArray, type HSLALike, type HSLAString, type HSLArguments, type HSLArray, type HSLLike, type HSLString, type HexLike, 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, type JavaScriptFunction, type JavaScriptNumber, type JavaScriptTypeMap, type JavaScriptTypes, 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, NodeJSCustomInspect, type Predicate, 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, checkArray, checkHex, checkNumber, checkNumberArray, checkString, checkStringArray, clamp, clampAngleDegree, clampAngleRadian, degreeToRadian, djb2, fnv1, getHexValue, hasProperty, lerp, logHypot, radianToDegree, sdbm, signCharacter };