@ntf/math 1.2.0 → 1.3.1

package/dist/index.d.mts

@@ -0,0 +1,754 @@
+declare function stringify<V>(value: V): string;
+interface IToString {
+    /**
+     * Returns a string representation of an object.
+     */
+    toString(): string;
+}
+
+interface IGeometryObject {
+    readonly area: number;
+    readonly perimeter: number;
+}
+
+interface ISize {
+    width: number;
+    height: 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 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;
+    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;
+}
+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;
+}
+
+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;
+}
+
+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;
+    toMat3(): Mat3;
+    toMat4(): Mat4;
+}
+
+/**
+ * Represents a 3D transform for 3D graphics
+ */
+declare class Transform {
+    /**
+     * The position of the object
+     */
+    position: Vec3;
+    /**
+     * The rotation of the object
+     */
+    rotation: Quaternion;
+    /**
+     * The scale of the object
+     */
+    scale: 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);
+    /**
+     * Convert the transform into a 4x3 matrix
+     * @returns A 4x4 matrix from the transform
+     */
+    toMat4(): Mat4;
+}
+
+/**
+ * Clamp `value` between `min` and `max`
+ * @param value The input value
+ * @param min The minimum value
+ * @param max The maximum value
+ * @returns A value between `min` and `max`
+ */
+declare function clamp<T extends number | bigint>(value: T, min: T, max: T): T;
+/**
+ * Calculate the natural logarithm of the magnitude of a complex number `a+bia+bi`
+ * @param a The input value a
+ * @param b The input value b
+ * @returns The result
+ */
+declare function log_hypot(a: number, b: number): number;
+declare const EPSILON = 1e-16;
+
+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 };