@predy-js/math 0.1.67

package/dist/index.js

@@ -0,0 +1,970 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const cos$2 = Math.cos;
+const sin$2 = Math.sin;
+const d2r$2 = Math.PI / 180;
+const tempMat3FromRotationZ = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+function mat3create() {
+    return new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+}
+function mat3MulMat3(out, a, b) {
+    const a00 = a[0], a01 = a[1], a02 = a[2];
+    const a10 = a[3], a11 = a[4], a12 = a[5];
+    const a20 = a[6], a21 = a[7], a22 = a[8];
+    const b00 = b[0], b01 = b[1], b02 = b[2];
+    const b10 = b[3], b11 = b[4], b12 = b[5];
+    const b20 = b[6], b21 = b[7], b22 = b[8];
+    out[0] = b00 * a00 + b01 * a10 + b02 * a20;
+    out[1] = b00 * a01 + b01 * a11 + b02 * a21;
+    out[2] = b00 * a02 + b01 * a12 + b02 * a22;
+    out[3] = b10 * a00 + b11 * a10 + b12 * a20;
+    out[4] = b10 * a01 + b11 * a11 + b12 * a21;
+    out[5] = b10 * a02 + b11 * a12 + b12 * a22;
+    out[6] = b20 * a00 + b21 * a10 + b22 * a20;
+    out[7] = b20 * a01 + b21 * a11 + b22 * a21;
+    out[8] = b20 * a02 + b21 * a12 + b22 * a22;
+    return out;
+}
+function mat3FromRotationZ(out, rad) {
+    if (!out) {
+        out = tempMat3FromRotationZ;
+    }
+    const s = sin$2(rad);
+    const c = cos$2(rad);
+    out[0] = c;
+    out[1] = s;
+    out[2] = 0;
+    out[3] = -s;
+    out[4] = c;
+    out[5] = 0;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 1;
+    return out;
+}
+function mat3FromRotationZYX(ret, x, y, z) {
+    const cosX = cos$2(x * d2r$2);
+    const cosY = cos$2(y * d2r$2);
+    const cosZ = cos$2(z * d2r$2);
+    const sinX = sin$2(x * d2r$2);
+    const sinY = sin$2(y * d2r$2);
+    const sinZ = sin$2(z * d2r$2);
+    ret[0] = cosY * cosZ;
+    ret[1] = cosY * sinZ;
+    ret[2] = -sinY;
+    ret[3] = -cosX * sinZ + sinX * sinY * cosZ;
+    ret[4] = cosX * cosZ + sinX * sinY * sinZ;
+    ret[5] = sinX * cosY;
+    ret[6] = sinZ * sinX + cosX * sinY * cosZ;
+    ret[7] = -sinX * cosZ + cosX * sinY * sinZ;
+    ret[8] = cosX * cosY;
+    return ret;
+}
+function mat3FromRotation(ret, rotation) {
+    return mat3FromRotationZYX(ret, -rotation[0], -rotation[1], -rotation[2]);
+}
+function mat3NormalFromMat4(out, a) {
+    const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+    const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+    const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    // Calculate the determinant
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+        return null;
+    }
+    det = 1.0 / det;
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    return out;
+}
+function mat3Translate(out, a, v) {
+    const a00 = a[0], a01 = a[1], a02 = a[2], a10 = a[3], a11 = a[4], a12 = a[5], a20 = a[6], a21 = a[7], a22 = a[8], x = v[0], y = v[1];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a10;
+    out[4] = a11;
+    out[5] = a12;
+    out[6] = x * a00 + y * a10 + a20;
+    out[7] = x * a01 + y * a11 + a21;
+    out[8] = x * a02 + y * a12 + a22;
+    return out;
+}
+function mat3Rotate(out, a, rad) {
+    const a00 = a[0], a01 = a[1], a02 = a[2], a10 = a[3], a11 = a[4], a12 = a[5], a20 = a[6], a21 = a[7], a22 = a[8], s = sin$2(rad), c = cos$2(rad);
+    out[0] = c * a00 + s * a10;
+    out[1] = c * a01 + s * a11;
+    out[2] = c * a02 + s * a12;
+    out[3] = c * a10 - s * a00;
+    out[4] = c * a11 - s * a01;
+    out[5] = c * a12 - s * a02;
+    out[6] = a20;
+    out[7] = a21;
+    out[8] = a22;
+    return out;
+}
+function mat3Scale(out, a, v) {
+    const x = v[0], y = v[1];
+    out[0] = x * a[0];
+    out[1] = x * a[1];
+    out[2] = x * a[2];
+    out[3] = y * a[3];
+    out[4] = y * a[4];
+    out[5] = y * a[5];
+    out[6] = a[6];
+    out[7] = a[7];
+    out[8] = a[8];
+    return out;
+}
+
+const d2r$1 = Math.PI / 180;
+const matrixRotation = new Float32Array(9);
+const quatOut = [0, 0, 0, 1];
+const temps = [0, 0, 0];
+function mat4create() {
+    return new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+}
+function mat4fromRotationTranslationScale(out, q, v, s) {
+    const x = q[0];
+    const y = q[1];
+    const z = q[2];
+    const w = q[3];
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+    const xx = x * x2;
+    const xy = x * y2;
+    const xz = x * z2;
+    const yy = y * y2;
+    const yz = y * z2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+    const sx = s[0];
+    const sy = s[1];
+    const sz = s[2];
+    out[0] = (1 - (yy + zz)) * sx;
+    out[1] = (xy + wz) * sx;
+    out[2] = (xz - wy) * sx;
+    out[3] = 0;
+    out[4] = (xy - wz) * sy;
+    out[5] = (1 - (xx + zz)) * sy;
+    out[6] = (yz + wx) * sy;
+    out[7] = 0;
+    out[8] = (xz + wy) * sz;
+    out[9] = (yz - wx) * sz;
+    out[10] = (1 - (xx + yy)) * sz;
+    out[11] = 0;
+    out[12] = v[0];
+    out[13] = v[1];
+    out[14] = v[2];
+    out[15] = 1;
+    return out;
+}
+function invertMat4(out, a) {
+    const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+    const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+    const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    // Calculate the determinant
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+        return null;
+    }
+    det = 1.0 / det;
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return out;
+}
+function mat4Determinate(a) {
+    const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+    const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+    const a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+}
+function getMat4TR(mat4, translate, quat, scaling) {
+    const m11 = mat4[0];
+    const m12 = mat4[1];
+    const m13 = mat4[2];
+    const m21 = mat4[4];
+    const m22 = mat4[5];
+    const m23 = mat4[6];
+    const m31 = mat4[8];
+    const m32 = mat4[9];
+    const m33 = mat4[10];
+    if (quat) {
+        // copy from gl-matrix
+        const is1 = 1 / scaling[0];
+        const is2 = 1 / scaling[1];
+        const is3 = 1 / scaling[2];
+        matrixRotation[0] = m11 * is1;
+        matrixRotation[1] = m12 * is1;
+        matrixRotation[2] = m13 * is1;
+        matrixRotation[3] = m21 * is2;
+        matrixRotation[4] = m22 * is2;
+        matrixRotation[5] = m23 * is2;
+        matrixRotation[6] = m31 * is3;
+        matrixRotation[7] = m32 * is3;
+        matrixRotation[8] = m33 * is3;
+        const fTrace = matrixRotation[0] + matrixRotation[4] + matrixRotation[8];
+        let fRoot;
+        if (fTrace > 0.0) {
+            // |w| > 1/2, may as well choose w > 1/2
+            fRoot = Math.sqrt(fTrace + 1.0); // 2w
+            quatOut[3] = 0.5 * fRoot;
+            fRoot = 0.5 / fRoot; // 1/(4w)
+            quatOut[0] = (matrixRotation[5] - matrixRotation[7]) * fRoot;
+            quatOut[1] = (matrixRotation[6] - matrixRotation[2]) * fRoot;
+            quatOut[2] = (matrixRotation[1] - matrixRotation[3]) * fRoot;
+        }
+        else {
+            // |w| <= 1/2
+            let i = 0;
+            if (matrixRotation[4] > matrixRotation[0]) {
+                i = 1;
+            }
+            if (matrixRotation[8] > matrixRotation[i * 3 + i]) {
+                i = 2;
+            }
+            const j = (i + 1) % 3;
+            const k = (i + 2) % 3;
+            fRoot = Math.sqrt(matrixRotation[i * 3 + i] - matrixRotation[j * 3 + j] - matrixRotation[k * 3 + k] + 1.0);
+            quatOut[i] = 0.5 * fRoot;
+            fRoot = 0.5 / fRoot;
+            quatOut[3] = (matrixRotation[j * 3 + k] - matrixRotation[k * 3 + j]) * fRoot;
+            quatOut[j] = (matrixRotation[j * 3 + i] + matrixRotation[i * 3 + j]) * fRoot;
+            quatOut[k] = (matrixRotation[k * 3 + i] + matrixRotation[i * 3 + k]) * fRoot;
+        }
+        quat[0] = quatOut[0];
+        quat[1] = quatOut[1];
+        quat[2] = quatOut[2];
+        quat[3] = quatOut[3];
+    }
+    if (translate) {
+        translate[0] = mat4[12];
+        translate[1] = mat4[13];
+        translate[2] = mat4[14];
+    }
+}
+function getMat4TRS(mat4, translate, quat, scaling = temps) {
+    const m11 = mat4[0];
+    const m12 = mat4[1];
+    const m13 = mat4[2];
+    const m21 = mat4[4];
+    const m22 = mat4[5];
+    const m23 = mat4[6];
+    const m31 = mat4[8];
+    const m32 = mat4[9];
+    const m33 = mat4[10];
+    const det = mat4Determinate(mat4);
+    scaling[0] = Math.hypot(m11, m12, m13);
+    scaling[1] = Math.hypot(m21, m22, m23);
+    scaling[2] = Math.hypot(m31, m32, m33);
+    if (det < 0) {
+        scaling[0] = -scaling[0];
+    }
+    return getMat4TR(mat4, translate, quat, scaling);
+}
+function mat4multiply(out, a, b) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+    // Cache only the current line of the second matrix
+    let b0 = b[0];
+    let b1 = b[1];
+    let b2 = b[2];
+    let b3 = b[3];
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    return out;
+}
+function mat4Clone(out, from) {
+    for (let i = 0; i < 16; i++) {
+        out[i] = from[i];
+    }
+    return out;
+}
+function mat4invert(out, a) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    // Calculate the determinant
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+        for (let i = 0; i < 16; i++) {
+            out[i] = NaN;
+        }
+        return out;
+    }
+    det = 1.0 / det;
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return out;
+}
+function mat4translate(out, a, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    let a00;
+    let a01;
+    let a02;
+    let a03;
+    let a10;
+    let a11;
+    let a12;
+    let a13;
+    let a20;
+    let a21;
+    let a22;
+    let a23;
+    if (a === out) {
+        out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+        out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+        out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+        out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+    }
+    else {
+        a00 = a[0];
+        a01 = a[1];
+        a02 = a[2];
+        a03 = a[3];
+        a10 = a[4];
+        a11 = a[5];
+        a12 = a[6];
+        a13 = a[7];
+        a20 = a[8];
+        a21 = a[9];
+        a22 = a[10];
+        a23 = a[11];
+        out[0] = a00;
+        out[1] = a01;
+        out[2] = a02;
+        out[3] = a03;
+        out[4] = a10;
+        out[5] = a11;
+        out[6] = a12;
+        out[7] = a13;
+        out[8] = a20;
+        out[9] = a21;
+        out[10] = a22;
+        out[11] = a23;
+        out[12] = a00 * x + a10 * y + a20 * z + a[12];
+        out[13] = a01 * x + a11 * y + a21 * z + a[13];
+        out[14] = a02 * x + a12 * y + a22 * z + a[14];
+        out[15] = a03 * x + a13 * y + a23 * z + a[15];
+    }
+    return out;
+}
+function mat4scale(out, a, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    out[0] = a[0] * x;
+    out[1] = a[1] * x;
+    out[2] = a[2] * x;
+    out[3] = a[3] * x;
+    out[4] = a[4] * y;
+    out[5] = a[5] * y;
+    out[6] = a[6] * y;
+    out[7] = a[7] * y;
+    out[8] = a[8] * z;
+    out[9] = a[9] * z;
+    out[10] = a[10] * z;
+    out[11] = a[11] * z;
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+    return out;
+}
+function mat4rotate(out, a, rad, axis) {
+    let x = axis[0];
+    let y = axis[1];
+    let z = axis[2];
+    let len = Math.sqrt(x * x + y * y + z * z);
+    len = 1 / len;
+    x *= len;
+    y *= len;
+    z *= len;
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const t = 1 - c;
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    // Construct the elements of the rotation matrix
+    const b00 = x * x * t + c;
+    const b01 = y * x * t + z * s;
+    const b02 = z * x * t - y * s;
+    const b10 = x * y * t - z * s;
+    const b11 = y * y * t + c;
+    const b12 = z * y * t + x * s;
+    const b20 = x * z * t + y * s;
+    const b21 = y * z * t - x * s;
+    const b22 = z * z * t + c;
+    // Perform rotation-specific matrix multiplication
+    out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+    out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+    out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+    out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+    out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+    out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+    out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+    out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+    out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+    out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+    out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+    out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+    if (a !== out) {
+        // If the source and destination differ, copy the unchanged last row
+        out[12] = a[12];
+        out[13] = a[13];
+        out[14] = a[14];
+        out[15] = a[15];
+    }
+    return out;
+}
+function mat4perspective(out, fovy, aspect, near, far, reverse) {
+    const f = 1.0 / Math.tan((fovy * d2r$1) / 2);
+    let nf;
+    out[0] = reverse ? f : f / aspect;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = reverse ? f * aspect : f;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = -1;
+    out[12] = 0;
+    out[13] = 0;
+    out[15] = 0;
+    if (far != null && far !== Infinity) {
+        nf = 1 / (near - far);
+        out[10] = (far + near) * nf;
+        out[14] = 2 * far * near * nf;
+    }
+    else {
+        out[10] = -1;
+        out[14] = -2 * near;
+    }
+    return out;
+}
+function mat4identity(out) {
+    out[0] = 1;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = 1;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[10] = 1;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+}
+
+const cos$1 = Math.cos;
+const sin$1 = Math.sin;
+function vecAdd(out, a, b) {
+    for (let i = 0, len = a.length; i < len; i++) {
+        out[i] = a[i] + b[i];
+    }
+    return out;
+}
+function vecFill(out, number) {
+    for (let i = 0, len = out.length; i < len; i++) {
+        out[i] = number;
+    }
+    return out;
+}
+function vecAddCombine(out, a, b) {
+    if (a && b) {
+        for (let i = 0, len = a.length; i < len; i++) {
+            out[i] = a[i] + b[i];
+        }
+        return out;
+    }
+    return a || b;
+}
+function vecAssign(out, a, count, start = 0) {
+    for (let i = 0; i < count; i++) {
+        out[i] = a[i + start];
+    }
+    return out;
+}
+function vecMulCombine(out, a, b) {
+    if (a && b) {
+        for (let i = 0, len = a.length; i < len; i++) {
+            out[i] = a[i] * b[i];
+        }
+    }
+    else if (a) {
+        if (out !== a) {
+            for (let i = 0; i < a.length; i++) {
+                out[i] = a[i];
+            }
+        }
+    }
+    else if (b) {
+        if (out !== b) {
+            for (let i = 0; i < b.length; i++) {
+                out[i] = b[i];
+            }
+        }
+    }
+    return out;
+}
+function vecMinus(out, v0, v1) {
+    for (let i = 0, len = v0.length; i < len; i++) {
+        out[i] = v0[i] - v1[i];
+    }
+    return out;
+}
+function vecSquareDistance(v0, v1) {
+    let sum = 0;
+    for (let i = 0, len = v0.length; i < len; i++) {
+        const d = v0[i] - v1[i];
+        sum += d * d;
+    }
+    return sum;
+}
+const NumberEpsilon = Number.EPSILON || Math.pow(2, -32);
+function vecNormalize(out, a) {
+    if (arguments.length === 1) {
+        a = out;
+        out = [];
+    }
+    const sum = Math.hypot(...a);
+    if (sum === 0) {
+        return vecAssign(out, a, a.length);
+    }
+    for (let i = 0; i < a.length; i++) {
+        out[i] = a[i] / sum;
+    }
+    return out;
+}
+function vecMulScalar(out, vec, a) {
+    for (let i = 0, len = vec.length; i < len; i++) {
+        out[i] = vec[i] * a;
+    }
+    return out;
+}
+function vecDot(out, a, b) {
+    if (isNaN(b)) {
+        let sum = 0;
+        for (let i = 0, len = a.length; i < len; i++) {
+            sum += out[i] * a[i];
+        }
+        return sum;
+    }
+    for (let i = 0, len = a.length; i < len; i++) {
+        out[i] = a[i] * b;
+    }
+    return (out);
+}
+function vec2TransformByMat3(out, a, m) {
+    const x = a[0], y = a[1];
+    out[0] = m[0] * x + m[3] * y + m[6];
+    out[1] = m[1] * x + m[4] * y + m[7];
+    return out;
+}
+function isZeroVec(vec) {
+    for (let i = 0, len = vec.length; i < len; i++) {
+        if (Math.abs(vec[i]) > NumberEpsilon) {
+            return false;
+        }
+    }
+    return true;
+}
+function rotateVec2(out, vec2, angleInRad) {
+    const c = cos$1(angleInRad);
+    const s = sin$1(angleInRad);
+    const x = vec2[0];
+    const y = vec2[1];
+    out[0] = c * x + s * y;
+    out[1] = -s * x + c * y;
+    return out;
+}
+function clamp(v, min, max) {
+    return v > max ? max : (v < min ? min : v);
+}
+
+const r2d = 180 / Math.PI;
+function vec3Create(v) {
+    if (v) {
+        return [v[0], v[1], v[2]];
+    }
+    return [0, 0, 0];
+}
+function vec3AddVec3(out, a, b) {
+    out[0] = a[0] + b[0];
+    out[1] = a[1] + b[1];
+    out[2] = a[2] + b[2];
+    return out;
+}
+function vec3Cross(out, a, b) {
+    const ax = a[0], ay = a[1], az = a[2];
+    const bx = b[0], by = b[1], bz = b[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+}
+function vec3MulMat4(out, vec3, mat4) {
+    const x = vec3[0], y = vec3[1], z = vec3[2];
+    const w = (mat4[3] * x + mat4[7] * y + mat4[11] * z + mat4[15]) || 1;
+    out[0] = (mat4[0] * x + mat4[4] * y + mat4[8] * z + mat4[12]) / w;
+    out[1] = (mat4[1] * x + mat4[5] * y + mat4[9] * z + mat4[13]) / w;
+    out[2] = (mat4[2] * x + mat4[6] * y + mat4[10] * z + mat4[14]) / w;
+    return out;
+}
+function vec3TranslateByMat4(out, vec3, matrix4) {
+    out[0] = vec3[0] + matrix4[12];
+    out[1] = vec3[1] + matrix4[13];
+    out[2] = vec3[2] + matrix4[14];
+    return out;
+}
+function vec3RotateByMat4(out, a, m) {
+    const x = a[0], y = a[1], z = a[2];
+    const w = (m[3] * x + m[7] * y + m[11] * z + m[15]) || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+    return out;
+}
+function vec3MulMat3(out, a, m) {
+    const x = a[0], y = a[1], z = a[2];
+    out[0] = x * m[0] + y * m[3] + z * m[6];
+    out[1] = x * m[1] + y * m[4] + z * m[7];
+    out[2] = x * m[2] + y * m[5] + z * m[8];
+    return out;
+}
+function ensureVec3(vec, defaultVec = [0, 0, 0]) {
+    const ret = [defaultVec[0], defaultVec[1], defaultVec[2]];
+    if (vec) {
+        for (let i = 0; i < 3; i++) {
+            if (!Number.isNaN(+vec[i])) {
+                ret[i] = +vec[i];
+            }
+        }
+    }
+    return ret;
+}
+function rotationZYXFromMat3(out, mat3) {
+    const te = mat3;
+    const m11 = te[0], m12 = te[3]; te[6];
+    const m21 = te[1], m22 = te[4]; te[7];
+    const m31 = te[2], m32 = te[5], m33 = te[8];
+    out[1] = Math.asin(clamp(-m31, -1, 1)) * r2d;
+    if (Math.abs(m31) < 0.9999999) {
+        out[0] = Math.atan2(m32, m33) * r2d;
+        out[2] = Math.atan2(m21, m11) * r2d;
+    }
+    else {
+        out[0] = 0;
+        out[2] = Math.atan2(-m12, m22) * r2d;
+    }
+    return out;
+}
+function vec3MulNum(out, v3, mul) {
+    out[0] = v3[0] * mul;
+    out[1] = v3[1] * mul;
+    out[2] = v3[2] * mul;
+    return out;
+}
+function rotationFromMat3(out, mat3) {
+    rotationZYXFromMat3(out, mat3);
+    return out;
+}
+const tempUV = vec3Create();
+const tempUUV = vec3Create();
+function vec3RotateByQuat(out, a, quat) {
+    const x = quat[0], y = quat[1], z = quat[2], w = quat[3];
+    const qvec = [x, y, z];
+    const uv = vec3Cross(tempUV, qvec, a);
+    const uuv = vec3Cross(tempUUV, qvec, uv);
+    vec3MulNum(uuv, uuv, 2);
+    vec3MulNum(uv, uv, 2 * w);
+    vec3AddVec3(uuv, uuv, uv);
+    vec3AddVec3(out, a, uuv);
+    return out;
+}
+
+const d2r = Math.PI / 180;
+const cos = Math.cos;
+const sin = Math.sin;
+function quatCreate() {
+    return new Float32Array([0, 0, 0, 1]);
+}
+function quatMultiply(out, a, b) {
+    const ax = a[0], ay = a[1], az = a[2], aw = a[3];
+    const bx = b[0], by = b[1], bz = b[2], bw = b[3];
+    out[0] = ax * bw + aw * bx + ay * bz - az * by;
+    out[1] = ay * bw + aw * by + az * bx - ax * bz;
+    out[2] = az * bw + aw * bz + ax * by - ay * bx;
+    out[3] = aw * bw - ax * bx - ay * by - az * bz;
+    return out;
+}
+function mat3FromQuat(out, quat) {
+    const x = quat[0], y = quat[1], z = quat[2], w = quat[3];
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+    const xx = x * x2;
+    const yx = y * x2;
+    const yy = y * y2;
+    const zx = z * x2;
+    const zy = z * y2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+    out[0] = 1 - yy - zz;
+    out[3] = yx - wz;
+    out[6] = zx + wy;
+    out[1] = yx + wz;
+    out[4] = 1 - xx - zz;
+    out[7] = zy - wx;
+    out[2] = zx - wy;
+    out[5] = zy + wx;
+    out[8] = 1 - xx - yy;
+    return out;
+}
+function quatEquals(q1, q2) {
+    const tolerance = 1e-6;
+    return q1.length === q2.length && q1.every((component, index) => Math.abs(component - q2[index]) < tolerance ||
+        Math.abs(component + q2[index]) < tolerance);
+}
+function quatFromRotation(out, x, y, z) {
+    const c1 = cos((x * d2r) / 2);
+    const c2 = cos((y * d2r) / 2);
+    const c3 = cos((z * d2r) / 2);
+    const s1 = sin((x * d2r) / 2);
+    const s2 = sin((y * d2r) / 2);
+    const s3 = sin((z * d2r) / 2);
+    out[0] = s1 * c2 * c3 - c1 * s2 * s3;
+    out[1] = c1 * s2 * c3 + s1 * c2 * s3;
+    out[2] = c1 * c2 * s3 - s1 * s2 * c3;
+    out[3] = c1 * c2 * c3 + s1 * s2 * s3;
+    return out;
+}
+function quatStar(out, quat) {
+    const x = quat[0], y = quat[1], z = quat[2], w = quat[3];
+    out[0] = -x;
+    out[1] = -y;
+    out[2] = -z;
+    out[3] = w;
+    return out;
+}
+
+exports.NumberEpsilon = NumberEpsilon;
+exports.clamp = clamp;
+exports.ensureVec3 = ensureVec3;
+exports.getMat4TR = getMat4TR;
+exports.getMat4TRS = getMat4TRS;
+exports.invertMat4 = invertMat4;
+exports.isZeroVec = isZeroVec;
+exports.mat3FromQuat = mat3FromQuat;
+exports.mat3FromRotation = mat3FromRotation;
+exports.mat3FromRotationZ = mat3FromRotationZ;
+exports.mat3MulMat3 = mat3MulMat3;
+exports.mat3NormalFromMat4 = mat3NormalFromMat4;
+exports.mat3Rotate = mat3Rotate;
+exports.mat3Scale = mat3Scale;
+exports.mat3Translate = mat3Translate;
+exports.mat3create = mat3create;
+exports.mat4Clone = mat4Clone;
+exports.mat4Determinate = mat4Determinate;
+exports.mat4create = mat4create;
+exports.mat4fromRotationTranslationScale = mat4fromRotationTranslationScale;
+exports.mat4identity = mat4identity;
+exports.mat4invert = mat4invert;
+exports.mat4multiply = mat4multiply;
+exports.mat4perspective = mat4perspective;
+exports.mat4rotate = mat4rotate;
+exports.mat4scale = mat4scale;
+exports.mat4translate = mat4translate;
+exports.quatCreate = quatCreate;
+exports.quatEquals = quatEquals;
+exports.quatFromRotation = quatFromRotation;
+exports.quatMultiply = quatMultiply;
+exports.quatStar = quatStar;
+exports.rotateVec2 = rotateVec2;
+exports.rotationFromMat3 = rotationFromMat3;
+exports.vec2TransformByMat3 = vec2TransformByMat3;
+exports.vec3AddVec3 = vec3AddVec3;
+exports.vec3Create = vec3Create;
+exports.vec3Cross = vec3Cross;
+exports.vec3MulMat3 = vec3MulMat3;
+exports.vec3MulMat4 = vec3MulMat4;
+exports.vec3MulNum = vec3MulNum;
+exports.vec3RotateByMat4 = vec3RotateByMat4;
+exports.vec3RotateByQuat = vec3RotateByQuat;
+exports.vec3TranslateByMat4 = vec3TranslateByMat4;
+exports.vecAdd = vecAdd;
+exports.vecAddCombine = vecAddCombine;
+exports.vecAssign = vecAssign;
+exports.vecDot = vecDot;
+exports.vecFill = vecFill;
+exports.vecMinus = vecMinus;
+exports.vecMulCombine = vecMulCombine;
+exports.vecMulScalar = vecMulScalar;
+exports.vecNormalize = vecNormalize;
+exports.vecSquareDistance = vecSquareDistance;