fluidcad 0.0.2

package/lib/dist/math/point.test.js

@@ -0,0 +1,385 @@
+import { describe, it, expect } from "vitest";
+import { Point, Point2D, isPointLike, isPoint2DLike } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Axis } from "./axis.js";
+describe("Point", () => {
+    describe("constructor", () => {
+        it("creates a point with x, y, z coordinates", () => {
+            const p = new Point(1, 2, 3);
+            expect(p.x).toBe(1);
+            expect(p.y).toBe(2);
+            expect(p.z).toBe(3);
+        });
+    });
+    describe("equals", () => {
+        it("returns true for identical points", () => {
+            const p1 = new Point(1, 2, 3);
+            const p2 = new Point(1, 2, 3);
+            expect(p1.equals(p2)).toBe(true);
+        });
+        it("returns false for different points", () => {
+            const p1 = new Point(1, 2, 3);
+            const p2 = new Point(1, 2, 4);
+            expect(p1.equals(p2)).toBe(false);
+        });
+        it("supports tolerance", () => {
+            const p1 = new Point(1, 2, 3);
+            const p2 = new Point(1.001, 2.001, 3.001);
+            expect(p1.equals(p2, 0.01)).toBe(true);
+            expect(p1.equals(p2, 0.0001)).toBe(false);
+        });
+    });
+    describe("distanceTo", () => {
+        it("computes distance to another point", () => {
+            const p1 = new Point(0, 0, 0);
+            const p2 = new Point(3, 4, 0);
+            expect(p1.distanceTo(p2)).toBe(5);
+        });
+        it("computes distance to a vector", () => {
+            const p = new Point(0, 0, 0);
+            const v = new Vector3d(3, 4, 0);
+            expect(p.distanceTo(v)).toBe(5);
+        });
+        it("returns 0 for same point", () => {
+            const p1 = new Point(1, 2, 3);
+            const p2 = new Point(1, 2, 3);
+            expect(p1.distanceTo(p2)).toBe(0);
+        });
+    });
+    describe("add", () => {
+        it("adds a vector to point", () => {
+            const p = new Point(1, 2, 3);
+            const v = new Vector3d(4, 5, 6);
+            const result = p.add(v);
+            expect(result.x).toBe(5);
+            expect(result.y).toBe(7);
+            expect(result.z).toBe(9);
+        });
+        it("is immutable", () => {
+            const p = new Point(1, 2, 3);
+            const v = new Vector3d(4, 5, 6);
+            p.add(v);
+            expect(p.x).toBe(1);
+        });
+    });
+    describe("subtract", () => {
+        it("subtracts a vector from point", () => {
+            const p = new Point(5, 7, 9);
+            const v = new Vector3d(1, 2, 3);
+            const result = p.subtract(v);
+            expect(result.x).toBe(4);
+            expect(result.y).toBe(5);
+            expect(result.z).toBe(6);
+        });
+    });
+    describe("multiply", () => {
+        it("multiplies point by scalar", () => {
+            const p = new Point(1, 2, 3);
+            const result = p.multiply(2);
+            expect(result.x).toBe(2);
+            expect(result.y).toBe(4);
+            expect(result.z).toBe(6);
+        });
+    });
+    describe("translate", () => {
+        it("translates point by dx, dy, dz", () => {
+            const p = new Point(1, 2, 3);
+            const result = p.translate(10, 20, 30);
+            expect(result.x).toBe(11);
+            expect(result.y).toBe(22);
+            expect(result.z).toBe(33);
+        });
+        it("defaults dz to 0", () => {
+            const p = new Point(1, 2, 3);
+            const result = p.translate(10, 20);
+            expect(result.z).toBe(3);
+        });
+    });
+    describe("translateX/Y/Z", () => {
+        it("translateX moves along X axis", () => {
+            const p = new Point(1, 2, 3);
+            const result = p.translateX(10);
+            expect(result.x).toBe(11);
+            expect(result.y).toBe(2);
+            expect(result.z).toBe(3);
+        });
+        it("translateY moves along Y axis", () => {
+            const p = new Point(1, 2, 3);
+            const result = p.translateY(10);
+            expect(result.x).toBe(1);
+            expect(result.y).toBe(12);
+            expect(result.z).toBe(3);
+        });
+        it("translateZ moves along Z axis", () => {
+            const p = new Point(1, 2, 3);
+            const result = p.translateZ(10);
+            expect(result.x).toBe(1);
+            expect(result.y).toBe(2);
+            expect(result.z).toBe(13);
+        });
+    });
+    describe("vectorTo", () => {
+        it("returns vector from this point to another", () => {
+            const p1 = new Point(1, 2, 3);
+            const p2 = new Point(4, 6, 8);
+            const v = p1.vectorTo(p2);
+            expect(v.x).toBe(3);
+            expect(v.y).toBe(4);
+            expect(v.z).toBe(5);
+        });
+    });
+    describe("lerp", () => {
+        it("interpolates between points", () => {
+            const p1 = new Point(0, 0, 0);
+            const p2 = new Point(10, 10, 10);
+            const result = p1.lerp(p2, 0.5);
+            expect(result.x).toBe(5);
+            expect(result.y).toBe(5);
+            expect(result.z).toBe(5);
+        });
+    });
+    describe("toVector3d", () => {
+        it("converts point to vector", () => {
+            const p = new Point(1, 2, 3);
+            const v = p.toVector3d();
+            expect(v).toBeInstanceOf(Vector3d);
+            expect(v.x).toBe(1);
+            expect(v.y).toBe(2);
+            expect(v.z).toBe(3);
+        });
+    });
+    describe("toPoint2D", () => {
+        it("converts to Point2D (drops z)", () => {
+            const p = new Point(1, 2, 3);
+            const p2d = p.toPoint2D();
+            expect(p2d).toBeInstanceOf(Point2D);
+            expect(p2d.x).toBe(1);
+            expect(p2d.y).toBe(2);
+        });
+    });
+    describe("static methods", () => {
+        it("origin returns (0,0,0)", () => {
+            const p = Point.origin();
+            expect(p.x).toBe(0);
+            expect(p.y).toBe(0);
+            expect(p.z).toBe(0);
+        });
+        it("fromArray creates point from array", () => {
+            const p = Point.fromArray([1, 2, 3]);
+            expect(p.x).toBe(1);
+            expect(p.y).toBe(2);
+            expect(p.z).toBe(3);
+        });
+        it("fromVector3d creates point from vector", () => {
+            const v = new Vector3d(1, 2, 3);
+            const p = Point.fromVector3d(v);
+            expect(p.x).toBe(1);
+            expect(p.y).toBe(2);
+            expect(p.z).toBe(3);
+        });
+    });
+});
+describe("Point2D", () => {
+    describe("constructor", () => {
+        it("creates a point with x, y coordinates", () => {
+            const p = new Point2D(1, 2);
+            expect(p.x).toBe(1);
+            expect(p.y).toBe(2);
+        });
+    });
+    describe("equals", () => {
+        it("returns true for identical points", () => {
+            const p1 = new Point2D(1, 2);
+            const p2 = new Point2D(1, 2);
+            expect(p1.equals(p2)).toBe(true);
+        });
+        it("supports tolerance", () => {
+            const p1 = new Point2D(1, 2);
+            const p2 = new Point2D(1.001, 2.001);
+            expect(p1.equals(p2, 0.01)).toBe(true);
+        });
+    });
+    describe("distanceTo", () => {
+        it("computes distance correctly", () => {
+            const p1 = new Point2D(0, 0);
+            const p2 = new Point2D(3, 4);
+            expect(p1.distanceTo(p2)).toBe(5);
+        });
+    });
+    describe("add/subtract", () => {
+        it("adds points correctly", () => {
+            const p1 = new Point2D(1, 2);
+            const p2 = new Point2D(3, 4);
+            const result = p1.add(p2);
+            expect(result.x).toBe(4);
+            expect(result.y).toBe(6);
+        });
+        it("subtracts points correctly", () => {
+            const p1 = new Point2D(5, 7);
+            const p2 = new Point2D(2, 3);
+            const result = p1.subtract(p2);
+            expect(result.x).toBe(3);
+            expect(result.y).toBe(4);
+        });
+    });
+    describe("multiply", () => {
+        it("multiplies component-wise", () => {
+            const p1 = new Point2D(2, 3);
+            const p2 = new Point2D(4, 5);
+            const result = p1.multiply(p2);
+            expect(result.x).toBe(8);
+            expect(result.y).toBe(15);
+        });
+    });
+    describe("multiplyScalar", () => {
+        it("multiplies by scalar", () => {
+            const p = new Point2D(2, 3);
+            const result = p.multiplyScalar(2);
+            expect(result.x).toBe(4);
+            expect(result.y).toBe(6);
+        });
+    });
+    describe("normalize", () => {
+        it("returns unit vector", () => {
+            const p = new Point2D(3, 4);
+            const result = p.normalize();
+            expect(result.length()).toBeCloseTo(1);
+        });
+        it("returns zero for zero point", () => {
+            const p = new Point2D(0, 0);
+            const result = p.normalize();
+            expect(result.x).toBe(0);
+            expect(result.y).toBe(0);
+        });
+    });
+    describe("rotate", () => {
+        it("rotates around origin", () => {
+            const p = new Point2D(1, 0);
+            const result = p.rotate(Math.PI / 2);
+            expect(result.x).toBeCloseTo(0);
+            expect(result.y).toBeCloseTo(1);
+        });
+        it("rotates around custom pivot", () => {
+            const p = new Point2D(2, 0);
+            const pivot = new Point2D(1, 0);
+            const result = p.rotate(Math.PI / 2, pivot);
+            expect(result.x).toBeCloseTo(1);
+            expect(result.y).toBeCloseTo(1);
+        });
+    });
+    describe("toPoint", () => {
+        it("converts to Point with z=0 by default", () => {
+            const p2d = new Point2D(1, 2);
+            const p = p2d.toPoint();
+            expect(p.x).toBe(1);
+            expect(p.y).toBe(2);
+            expect(p.z).toBe(0);
+        });
+        it("converts to Point with custom z", () => {
+            const p2d = new Point2D(1, 2);
+            const p = p2d.toPoint(5);
+            expect(p.z).toBe(5);
+        });
+    });
+    describe("mirrorAroundPoint", () => {
+        it("mirrors point around origin", () => {
+            const p = new Point2D(2, 3);
+            const result = p.mirrorAroundPoint(Point2D.origin());
+            expect(result.x).toBe(-2);
+            expect(result.y).toBe(-3);
+        });
+        it("mirrors point around arbitrary pivot", () => {
+            const p = new Point2D(4, 2);
+            const pivot = new Point2D(2, 2);
+            const result = p.mirrorAroundPoint(pivot);
+            expect(result.x).toBe(0);
+            expect(result.y).toBe(2);
+        });
+        it("returns same point when mirroring around itself", () => {
+            const p = new Point2D(1, 1);
+            const result = p.mirrorAroundPoint(p);
+            expect(result.x).toBe(1);
+            expect(result.y).toBe(1);
+        });
+    });
+    describe("mirrorAroundAxis", () => {
+        it("mirrors point around Y-axis", () => {
+            const p = new Point2D(2, 3);
+            const yAxis = new Axis(Point.origin(), new Vector3d(0, 1, 0));
+            const result = p.mirrorAroundAxis(yAxis);
+            expect(result.x).toBeCloseTo(-2);
+            expect(result.y).toBeCloseTo(3);
+        });
+        it("mirrors point around X-axis", () => {
+            const p = new Point2D(2, 3);
+            const xAxis = new Axis(Point.origin(), new Vector3d(1, 0, 0));
+            const result = p.mirrorAroundAxis(xAxis);
+            expect(result.x).toBeCloseTo(2);
+            expect(result.y).toBeCloseTo(-3);
+        });
+        it("mirrors point around diagonal axis (y=x)", () => {
+            const p = new Point2D(1, 0);
+            const diagonalAxis = new Axis(Point.origin(), new Vector3d(1, 1, 0));
+            const result = p.mirrorAroundAxis(diagonalAxis);
+            expect(result.x).toBeCloseTo(0);
+            expect(result.y).toBeCloseTo(1);
+        });
+        it("point on axis remains unchanged", () => {
+            const p = new Point2D(2, 2);
+            const diagonalAxis = new Axis(Point.origin(), new Vector3d(1, 1, 0));
+            const result = p.mirrorAroundAxis(diagonalAxis);
+            expect(result.x).toBeCloseTo(2);
+            expect(result.y).toBeCloseTo(2);
+        });
+        it("mirrors around offset axis", () => {
+            const p = new Point2D(3, 1);
+            // Vertical axis at x=2
+            const axis = new Axis(new Point(2, 0, 0), new Vector3d(0, 1, 0));
+            const result = p.mirrorAroundAxis(axis);
+            expect(result.x).toBeCloseTo(1);
+            expect(result.y).toBeCloseTo(1);
+        });
+    });
+    describe("static methods", () => {
+        it("origin returns (0,0)", () => {
+            const p = Point2D.origin();
+            expect(p.x).toBe(0);
+            expect(p.y).toBe(0);
+        });
+        it("fromArray creates point from array", () => {
+            const p = Point2D.fromArray([1, 2]);
+            expect(p.x).toBe(1);
+            expect(p.y).toBe(2);
+        });
+    });
+});
+describe("helper functions", () => {
+    describe("isPointLike", () => {
+        it("returns true for Point", () => {
+            expect(isPointLike(new Point(1, 2, 3))).toBe(true);
+        });
+        it("returns true for array of 3", () => {
+            expect(isPointLike([1, 2, 3])).toBe(true);
+        });
+        it("returns true for object with x,y,z", () => {
+            expect(isPointLike({ x: 1, y: 2, z: 3 })).toBe(true);
+        });
+        it("returns false for Point2D", () => {
+            expect(isPointLike(new Point2D(1, 2))).toBe(false);
+        });
+    });
+    describe("isPoint2DLike", () => {
+        it("returns true for Point2D", () => {
+            expect(isPoint2DLike(new Point2D(1, 2))).toBe(true);
+        });
+        it("returns true for array of 2", () => {
+            expect(isPoint2DLike([1, 2])).toBe(true);
+        });
+        it("returns true for object with x,y only", () => {
+            expect(isPoint2DLike({ x: 1, y: 2 })).toBe(true);
+        });
+        it("returns false for Point", () => {
+            expect(isPoint2DLike(new Point(1, 2, 3))).toBe(false);
+        });
+    });
+});

package/lib/dist/math/quaternion.d.ts

@@ -0,0 +1,37 @@
+import { Vector3d } from "./vector3d.js";
+export declare class Quaternion {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+    constructor(x: number, y: number, z: number, w: number);
+    length(): number;
+    lengthSquared(): number;
+    normalize(): Quaternion;
+    conjugate(): Quaternion;
+    inverse(): Quaternion;
+    multiply(other: Quaternion): Quaternion;
+    dot(other: Quaternion): number;
+    rotateVector(v: Vector3d): Vector3d;
+    slerp(other: Quaternion, t: number): Quaternion;
+    equals(other: Quaternion, tolerance?: number): boolean;
+    toAxisAngle(): {
+        axis: Vector3d;
+        angle: number;
+    };
+    toEulerAngles(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    toMatrix(): number[];
+    clone(): Quaternion;
+    toArray(): [number, number, number, number];
+    toString(): string;
+    static identity(): Quaternion;
+    static fromAxisAngle(axis: Vector3d, angle: number): Quaternion;
+    static fromEulerAngles(x: number, y: number, z: number): Quaternion;
+    static fromRotationMatrix(m: number[]): Quaternion;
+    static lookAt(forward: Vector3d, up?: Vector3d): Quaternion;
+    static fromArray(arr: [number, number, number, number]): Quaternion;
+}

package/lib/dist/math/quaternion.js

@@ -0,0 +1,234 @@
+import { Vector3d } from "./vector3d.js";
+export class Quaternion {
+    x;
+    y;
+    z;
+    w;
+    constructor(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    }
+    lengthSquared() {
+        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
+    }
+    normalize() {
+        const len = this.length();
+        if (len === 0) {
+            return Quaternion.identity();
+        }
+        return new Quaternion(this.x / len, this.y / len, this.z / len, this.w / len);
+    }
+    conjugate() {
+        return new Quaternion(-this.x, -this.y, -this.z, this.w);
+    }
+    inverse() {
+        const lenSq = this.lengthSquared();
+        if (lenSq === 0) {
+            return Quaternion.identity();
+        }
+        return new Quaternion(-this.x / lenSq, -this.y / lenSq, -this.z / lenSq, this.w / lenSq);
+    }
+    multiply(other) {
+        return new Quaternion(this.w * other.x + this.x * other.w + this.y * other.z - this.z * other.y, this.w * other.y - this.x * other.z + this.y * other.w + this.z * other.x, this.w * other.z + this.x * other.y - this.y * other.x + this.z * other.w, this.w * other.w - this.x * other.x - this.y * other.y - this.z * other.z);
+    }
+    dot(other) {
+        return this.x * other.x + this.y * other.y + this.z * other.z + this.w * other.w;
+    }
+    rotateVector(v) {
+        const qv = new Quaternion(v.x, v.y, v.z, 0);
+        const result = this.multiply(qv).multiply(this.conjugate());
+        return new Vector3d(result.x, result.y, result.z);
+    }
+    slerp(other, t) {
+        let cosHalfTheta = this.dot(other);
+        let otherQ = other;
+        if (cosHalfTheta < 0) {
+            otherQ = new Quaternion(-other.x, -other.y, -other.z, -other.w);
+            cosHalfTheta = -cosHalfTheta;
+        }
+        if (cosHalfTheta >= 1.0) {
+            return this.clone();
+        }
+        const halfTheta = Math.acos(cosHalfTheta);
+        const sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta);
+        if (Math.abs(sinHalfTheta) < 0.001) {
+            return new Quaternion(this.x * 0.5 + otherQ.x * 0.5, this.y * 0.5 + otherQ.y * 0.5, this.z * 0.5 + otherQ.z * 0.5, this.w * 0.5 + otherQ.w * 0.5);
+        }
+        const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
+        const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+        return new Quaternion(this.x * ratioA + otherQ.x * ratioB, this.y * ratioA + otherQ.y * ratioB, this.z * ratioA + otherQ.z * ratioB, this.w * ratioA + otherQ.w * ratioB);
+    }
+    equals(other, tolerance = 0) {
+        if (tolerance === 0) {
+            return (this.x === other.x &&
+                this.y === other.y &&
+                this.z === other.z &&
+                this.w === other.w);
+        }
+        return (Math.abs(this.x - other.x) <= tolerance &&
+            Math.abs(this.y - other.y) <= tolerance &&
+            Math.abs(this.z - other.z) <= tolerance &&
+            Math.abs(this.w - other.w) <= tolerance);
+    }
+    toAxisAngle() {
+        const q = this.lengthSquared() !== 1 ? this.normalize() : this;
+        const angle = 2 * Math.acos(Math.max(-1, Math.min(1, q.w)));
+        const sinHalfAngle = Math.sqrt(1 - q.w * q.w);
+        if (sinHalfAngle < 0.0001) {
+            return { axis: Vector3d.unitX(), angle: 0 };
+        }
+        return {
+            axis: new Vector3d(q.x / sinHalfAngle, q.y / sinHalfAngle, q.z / sinHalfAngle),
+            angle,
+        };
+    }
+    toEulerAngles() {
+        const sinr_cosp = 2 * (this.w * this.x + this.y * this.z);
+        const cosr_cosp = 1 - 2 * (this.x * this.x + this.y * this.y);
+        const x = Math.atan2(sinr_cosp, cosr_cosp);
+        const sinp = 2 * (this.w * this.y - this.z * this.x);
+        let y;
+        if (Math.abs(sinp) >= 1) {
+            y = (Math.PI / 2) * (sinp < 0 ? -1 : 1);
+        }
+        else {
+            y = Math.asin(sinp);
+        }
+        const siny_cosp = 2 * (this.w * this.z + this.x * this.y);
+        const cosy_cosp = 1 - 2 * (this.y * this.y + this.z * this.z);
+        const z = Math.atan2(siny_cosp, cosy_cosp);
+        return { x, y, z };
+    }
+    toMatrix() {
+        const x2 = this.x + this.x;
+        const y2 = this.y + this.y;
+        const z2 = this.z + this.z;
+        const xx = this.x * x2;
+        const xy = this.x * y2;
+        const xz = this.x * z2;
+        const yy = this.y * y2;
+        const yz = this.y * z2;
+        const zz = this.z * z2;
+        const wx = this.w * x2;
+        const wy = this.w * y2;
+        const wz = this.w * z2;
+        // Column-major order for 4x4 matrix
+        return [
+            1 - (yy + zz), xy + wz, xz - wy, 0, // Column 0
+            xy - wz, 1 - (xx + zz), yz + wx, 0, // Column 1
+            xz + wy, yz - wx, 1 - (xx + yy), 0, // Column 2
+            0, 0, 0, 1, // Column 3
+        ];
+    }
+    clone() {
+        return new Quaternion(this.x, this.y, this.z, this.w);
+    }
+    toArray() {
+        return [this.x, this.y, this.z, this.w];
+    }
+    toString() {
+        return `Quaternion(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
+    }
+    static identity() {
+        return new Quaternion(0, 0, 0, 1);
+    }
+    static fromAxisAngle(axis, angle) {
+        const normalizedAxis = axis.normalize();
+        const halfAngle = angle / 2;
+        const sin = Math.sin(halfAngle);
+        return new Quaternion(normalizedAxis.x * sin, normalizedAxis.y * sin, normalizedAxis.z * sin, Math.cos(halfAngle));
+    }
+    static fromEulerAngles(x, y, z) {
+        const cx = Math.cos(x / 2);
+        const sx = Math.sin(x / 2);
+        const cy = Math.cos(y / 2);
+        const sy = Math.sin(y / 2);
+        const cz = Math.cos(z / 2);
+        const sz = Math.sin(z / 2);
+        return new Quaternion(sx * cy * cz - cx * sy * sz, cx * sy * cz + sx * cy * sz, cx * cy * sz - sx * sy * cz, cx * cy * cz + sx * sy * sz);
+    }
+    static fromRotationMatrix(m) {
+        // Column-major layout: m[col*4 + row]
+        const m00 = m[0], m01 = m[4], m02 = m[8];
+        const m10 = m[1], m11 = m[5], m12 = m[9];
+        const m20 = m[2], m21 = m[6], m22 = m[10];
+        const trace = m00 + m11 + m22;
+        let x, y, z, w;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1.0);
+            w = 0.25 / s;
+            x = (m21 - m12) * s;
+            y = (m02 - m20) * s;
+            z = (m10 - m01) * s;
+        }
+        else if (m00 > m11 && m00 > m22) {
+            const s = 2.0 * Math.sqrt(1.0 + m00 - m11 - m22);
+            w = (m21 - m12) / s;
+            x = 0.25 * s;
+            y = (m01 + m10) / s;
+            z = (m02 + m20) / s;
+        }
+        else if (m11 > m22) {
+            const s = 2.0 * Math.sqrt(1.0 + m11 - m00 - m22);
+            w = (m02 - m20) / s;
+            x = (m01 + m10) / s;
+            y = 0.25 * s;
+            z = (m12 + m21) / s;
+        }
+        else {
+            const s = 2.0 * Math.sqrt(1.0 + m22 - m00 - m11);
+            w = (m10 - m01) / s;
+            x = (m02 + m20) / s;
+            y = (m12 + m21) / s;
+            z = 0.25 * s;
+        }
+        return new Quaternion(x, y, z, w);
+    }
+    static lookAt(forward, up = Vector3d.unitY()) {
+        const f = forward.normalize();
+        const r = up.cross(f).normalize();
+        const u = f.cross(r);
+        const m00 = r.x, m01 = r.y, m02 = r.z;
+        const m10 = u.x, m11 = u.y, m12 = u.z;
+        const m20 = f.x, m21 = f.y, m22 = f.z;
+        const trace = m00 + m11 + m22;
+        let x, y, z, w;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1.0);
+            w = 0.25 / s;
+            x = (m21 - m12) * s;
+            y = (m02 - m20) * s;
+            z = (m10 - m01) * s;
+        }
+        else if (m00 > m11 && m00 > m22) {
+            const s = 2.0 * Math.sqrt(1.0 + m00 - m11 - m22);
+            w = (m21 - m12) / s;
+            x = 0.25 * s;
+            y = (m01 + m10) / s;
+            z = (m02 + m20) / s;
+        }
+        else if (m11 > m22) {
+            const s = 2.0 * Math.sqrt(1.0 + m11 - m00 - m22);
+            w = (m02 - m20) / s;
+            x = (m01 + m10) / s;
+            y = 0.25 * s;
+            z = (m12 + m21) / s;
+        }
+        else {
+            const s = 2.0 * Math.sqrt(1.0 + m22 - m00 - m11);
+            w = (m10 - m01) / s;
+            x = (m02 + m20) / s;
+            y = (m12 + m21) / s;
+            z = 0.25 * s;
+        }
+        return new Quaternion(x, y, z, w);
+    }
+    static fromArray(arr) {
+        return new Quaternion(arr[0], arr[1], arr[2], arr[3]);
+    }
+}

package/lib/dist/math/quaternion.test.d.ts

@@ -0,0 +1 @@
+export {};