linearly 0.3.0 → 0.4.2

package/lib/esm/mat2.js

@@ -0,0 +1,179 @@
+import * as Common from './common';
+export function of(m00, m01, m10, m11) {
+    return [m00, m01, m10, m11];
+}
+/**
+ * The identity matrix of mat2
+ *
+ */
+export const identity = Object.freeze([1, 0, 0, 1]);
+export const zero = Object.freeze([0, 0, 0, 0]);
+/**
+ * Transpose the values of a mat2
+ */
+export function transpose(a) {
+    // prettier-ignore
+    return [
+        a[0], a[2],
+        a[1], a[3],
+    ];
+}
+/**
+ * Inverts a mat2
+ */
+export function invert(a) {
+    const [a0, a1, a2, a3] = a;
+    // Calculate the determinant
+    const det = a0 * a3 - a2 * a1;
+    if (!det) {
+        return null;
+    }
+    const detinv = 1 / det;
+    // prettier-ignore
+    return [
+        a3 * detinv, -a1 * detinv,
+        -a2 * detinv, a0 * detinv
+    ];
+}
+/**
+ * Calculates the adjugate of a mat2
+ */
+export function adjoint(a) {
+    // Caching this value is necessary if out == a
+    const a0 = a[0];
+    return [a[3], -a[1], -a[2], a0];
+}
+/**
+ * Calculates the determinant of a mat2
+ * @returns determinant of a
+ */
+export function determinant(a) {
+    return a[0] * a[3] - a[2] * a[1];
+}
+/**
+ * Multiplies two mat2's
+ */
+export function multiply(a, b) {
+    const [a0, a1, a2, a3] = a;
+    const [b0, b1, b2, b3] = b;
+    return [
+        a0 * b0 + a2 * b1,
+        a1 * b0 + a3 * b1,
+        a0 * b2 + a2 * b3,
+        a1 * b2 + a3 * b3,
+    ];
+}
+/**
+ * Rotates a mat2 by the given angle
+ *
+ * @param a the matrix to rotate
+ * @param rad the angle to rotate the matrix by
+ */
+export function rotate(a, rad) {
+    const [a0, a1, a2, a3] = a;
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    return [a0 * c + a2 * s, a1 * c + a3 * s, a0 * -s + a2 * c, a1 * -s + a3 * c];
+}
+/**
+ * Scales the mat2 by the dimensions in the given vec2
+ **/
+export function scale(a, v) {
+    const [a0, a1, a2, a3] = a;
+    const [v0, v1] = v;
+    return [a0 * v0, a1 * v0, a2 * v1, a3 * v1];
+}
+/**
+ * Apply skew to the mat2d by the given angles
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew
+ */
+export function skew(m, ax, ay) {
+    return multiply(m, fromSkew(ax, ay));
+}
+/**
+ * Creates a matrix from a given angle
+ */
+export function fromRotation(rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    return [c, s, -s, c];
+}
+/**
+ * Creates a matrix from a vector scaling
+ */
+export function fromScaling(v) {
+    return [v[0], 0, 0, v[1]];
+}
+/**
+ * Creates a matrix from a vector skew
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew
+ */
+export function fromSkew(ax, ay) {
+    const x = Math.tan(ax);
+    const y = Math.tan(ay);
+    // prettier-ignore
+    return [
+        1, y,
+        x, 1,
+    ];
+}
+/**
+ * Returns Frobenius norm of a mat2
+ */
+export function frob(a) {
+    return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]);
+}
+/**
+ * Adds two mat2's
+ */
+export function add(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]];
+}
+/**
+ * Subtracts matrix b from matrix a
+ */
+export function subtract(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]];
+}
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export function exactEquals(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+}
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export function equals(a, b) {
+    const [a0, a1, a2, a3] = a;
+    const [b0, b1, b2, b3] = b;
+    return (Math.abs(a0 - b0) <=
+        Common.EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) &&
+        Math.abs(a1 - b1) <=
+            Common.EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) &&
+        Math.abs(a2 - b2) <=
+            Common.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) &&
+        Math.abs(a3 - b3) <=
+            Common.EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)));
+}
+/**
+ * Multiply each element of the matrix by a scalar.
+ *
+ * @param a the matrix to scale
+ * @param s amount to scale the matrix's elements by
+ */
+export function multiplyScalar(a, s) {
+    return [a[0] * s, a[1] * s, a[2] * s, a[3] * s];
+}
+/**
+ * Adds two mat2's after multiplying each element of the second operand by a scalar value.
+ */
+export function multiplyScalarAndAdd(a, b, scale) {
+    return [
+        a[0] + b[0] * scale,
+        a[1] + b[1] * scale,
+        a[2] + b[2] * scale,
+        a[3] + b[3] * scale,
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/mat2d.d.ts

@@ -0,0 +1,102 @@
+import { Vec2 } from './vec2';
+/**
+ * 2x3 Matrix
+ * @module mat2d
+ * @description
+ * A mat2d contains six elements defined as:
+ * <pre>
+ * [a, b,
+ *  c, d,
+ *  tx, ty]
+ * </pre>
+ * This is a short form for the 3x3 matrix:
+ * <pre>
+ * [a, b, 0,
+ *  c, d, 0,
+ *  tx, ty, 1]
+ * </pre>
+ * The last column is ignored so the array is shorter and operations are faster.
+ */
+export type Mat2d = readonly [number, number, number, number, number, number];
+export declare function of(a: number, b: number, c: number, d: number, tx: number, ty: number): Mat2d;
+/**
+ * The identity matrix of mat2d
+ */
+export declare const identity: readonly number[];
+export declare const zero: Mat2d;
+/**
+ * Inverts a mat2d
+ */
+export declare function invert(a: Mat2d): Mat2d | null;
+/**
+ * Calculates the determinant of a mat2d
+ */
+export declare function determinant(a: Mat2d): number;
+/**
+ * Multiplies two mat2d's
+ */
+export declare function multiply(a: Mat2d, b: Mat2d): Mat2d;
+/**
+ * Rotates a mat2d by the given angle
+ */
+export declare function rotate(a: Mat2d, rad: number): Mat2d;
+/**
+ * Scales the mat2d by the dimensions in the given vec2
+ **/
+export declare function scale(a: Mat2d, v: Vec2): Mat2d;
+/**
+ * Translates the mat2d by the dimensions in the given vec2
+ **/
+export declare function translate(m: Mat2d, v: Vec2): Mat2d;
+/**
+ * Apply skew to the mat2d by the given angles
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew
+ */
+export declare function skew(m: Mat2d, ax: number, ay: number): Mat2d;
+/**
+ * Creates a matrix from a given angle
+ * This is equivalent to (but much faster than):
+ */
+export declare function fromRotation(rad: number): Mat2d;
+/**
+ * Creates a matrix from a vector scaling
+ */
+export declare function fromScaling(v: Vec2): Mat2d;
+/**
+ * Creates a matrix from a vector translation
+ */
+export declare function fromTranslation(v: Vec2): Mat2d;
+/**
+ * Creates a matrix from a vector skew
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew
+ */
+export declare function fromSkew(ax: number, ay: number): Mat2d;
+/**
+ * Returns Frobenius norm of a mat2d
+ */
+export declare function frob(a: Mat2d): number;
+/**
+ * Adds two mat2d's
+ */
+export declare function add(a: Mat2d, b: Mat2d): Mat2d;
+/**
+ * Subtracts matrix b from matrix a
+ */
+export declare function subtract(a: Mat2d, b: Mat2d): Mat2d;
+/**
+ * Multiply each element of the matrix by a scalar.
+ */
+export declare function multiplyScalar(a: Mat2d, s: number): Mat2d;
+/**
+ * Adds two mat2d's after multiplying each element of the second operand by a scalar value.
+ */
+export declare function multiplyScalarAndAdd(a: Mat2d, b: Mat2d, scale: number): Mat2d;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export declare function exactEquals(a: Mat2d, b: Mat2d): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export declare function equals(a: Mat2d, b: Mat2d): boolean;
+//# sourceMappingURL=mat2d.d.ts.map

package/lib/esm/mat2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mat2d.d.ts","sourceRoot":"","sources":["../../src/mat2d.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAG7E,wBAAgB,EAAE,CACjB,CAAC,EAAE,MAAM,EAAG,CAAC,EAAE,MAAM,EACrB,CAAC,EAAE,MAAM,EAAG,CAAC,EAAE,MAAM,EACrB,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GACpB,KAAK,CAEP;AAED;;GAEG;AAEH,eAAO,MAAM,QAAQ,mBAInB,CAAA;AAEF,eAAO,MAAM,IAAI,EAAE,KAAyC,CAAA;AAE5D;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAmB7C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,UAEnC;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAYlD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAWnD;AAED;;IAEI;AACJ,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,KAAK,CAU9C;AAED;;IAEI;AACJ,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,KAAK,CAUlD;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,CAE5D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAU/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,KAAK,CAS1C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,KAAK,CAS9C;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,CAUtD;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,UAU5B;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAS7C;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CASlD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAOzD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAS7E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,WAS7C;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,WAiBxC"}

package/lib/esm/mat2d.js

@@ -0,0 +1,246 @@
+import * as Common from './common';
+// prettier-ignore
+export function of(a, b, c, d, tx, ty) {
+    return [a, b, c, d, tx, ty];
+}
+/**
+ * The identity matrix of mat2d
+ */
+// prettier-ignore
+export const identity = Object.freeze([
+    1, 0,
+    0, 1,
+    0, 0
+]);
+export const zero = Object.freeze([0, 0, 0, 0, 0, 0]);
+/**
+ * Inverts a mat2d
+ */
+export function invert(a) {
+    const [aa, ab, ac, ad, atx, aty] = a;
+    const det = aa * ad - ab * ac;
+    if (!det) {
+        return null;
+    }
+    const detinv = 1 / det;
+    // prettier-ignore
+    return [
+        ad * detinv, -ab * detinv,
+        -ac * detinv, aa * detinv,
+        (ac * aty - ad * atx) * detinv,
+        (ab * atx - aa * aty) * detinv,
+    ];
+}
+/**
+ * Calculates the determinant of a mat2d
+ */
+export function determinant(a) {
+    return a[0] * a[3] - a[1] * a[2];
+}
+/**
+ * Multiplies two mat2d's
+ */
+export function multiply(a, b) {
+    const [a0, a1, a2, a3, a4, a5] = a;
+    const [b0, b1, b2, b3, b4, b5] = b;
+    // prettier-ignore
+    return [
+        a0 * b0 + a2 * b1, a1 * b0 + a3 * b1,
+        a0 * b2 + a2 * b3, a1 * b2 + a3 * b3,
+        a0 * b4 + a2 * b5 + a4,
+        a1 * b4 + a3 * b5 + a5,
+    ];
+}
+/**
+ * Rotates a mat2d by the given angle
+ */
+export function rotate(a, rad) {
+    const [a0, a1, a2, a3, tx, ty] = a;
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    // prettier-ignore
+    return [
+        a0 * c + a2 * s, a1 * c + a3 * s,
+        a0 * -s + a2 * c, a1 * -s + a3 * c,
+        tx, ty
+    ];
+}
+/**
+ * Scales the mat2d by the dimensions in the given vec2
+ **/
+export function scale(a, v) {
+    const [a0, a1, a2, a3, tx, ty] = a;
+    const [sx, sy] = v;
+    // prettier-ignore
+    return [
+        a0 * sx, a1 * sx,
+        a2 * sy, a3 * sy,
+        tx, ty
+    ];
+}
+/**
+ * Translates the mat2d by the dimensions in the given vec2
+ **/
+export function translate(m, v) {
+    const [a, b, c, d, tx, ty] = m;
+    const [x, y] = v;
+    // prettier-ignore
+    return [
+        a, b,
+        c, d,
+        a * x + c * y + tx,
+        b * x + d * y + ty
+    ];
+}
+/**
+ * Apply skew to the mat2d by the given angles
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew
+ */
+export function skew(m, ax, ay) {
+    return multiply(m, fromSkew(ax, ay));
+}
+/**
+ * Creates a matrix from a given angle
+ * This is equivalent to (but much faster than):
+ */
+export function fromRotation(rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    // prettier-ignore
+    return [
+        c, s,
+        -s, c,
+        0, 0,
+    ];
+}
+/**
+ * Creates a matrix from a vector scaling
+ */
+export function fromScaling(v) {
+    const [x, y] = v;
+    // prettier-ignore
+    return [
+        x, 0,
+        0, y,
+        0, 0,
+    ];
+}
+/**
+ * Creates a matrix from a vector translation
+ */
+export function fromTranslation(v) {
+    const [x, y] = v;
+    // prettier-ignore
+    return [
+        1, 0,
+        0, 1,
+        x, y,
+    ];
+}
+/**
+ * Creates a matrix from a vector skew
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew
+ */
+export function fromSkew(ax, ay) {
+    const x = Math.tan(ax);
+    const y = Math.tan(ay);
+    // prettier-ignore
+    return [
+        1, y,
+        x, 1,
+        0, 0,
+    ];
+}
+/**
+ * Returns Frobenius norm of a mat2d
+ */
+export function frob(a) {
+    // prettier-ignore
+    return Math.sqrt(a[0] ** 2 +
+        a[1] ** 2 +
+        a[2] ** 2 +
+        a[3] ** 2 +
+        a[4] ** 2 +
+        a[5] ** 2 + 1);
+}
+/**
+ * Adds two mat2d's
+ */
+export function add(a, b) {
+    return [
+        a[0] + b[0],
+        a[1] + b[1],
+        a[2] + b[2],
+        a[3] + b[3],
+        a[4] + b[4],
+        a[5] + b[5],
+    ];
+}
+/**
+ * Subtracts matrix b from matrix a
+ */
+export function subtract(a, b) {
+    return [
+        a[0] - b[0],
+        a[1] - b[1],
+        a[2] - b[2],
+        a[3] - b[3],
+        a[4] - b[4],
+        a[5] - b[5],
+    ];
+}
+/**
+ * Multiply each element of the matrix by a scalar.
+ */
+export function multiplyScalar(a, s) {
+    // prettier-ignore
+    return [
+        a[0] * s, a[1] * s,
+        a[2] * s, a[3] * s,
+        a[4] * s, a[5] * s,
+    ];
+}
+/**
+ * Adds two mat2d's after multiplying each element of the second operand by a scalar value.
+ */
+export function multiplyScalarAndAdd(a, b, scale) {
+    return [
+        a[0] + b[0] * scale,
+        a[1] + b[1] * scale,
+        a[2] + b[2] * scale,
+        a[3] + b[3] * scale,
+        a[4] + b[4] * scale,
+        a[5] + b[5] * scale,
+    ];
+}
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export function exactEquals(a, b) {
+    return (a[0] === b[0] &&
+        a[1] === b[1] &&
+        a[2] === b[2] &&
+        a[3] === b[3] &&
+        a[4] === b[4] &&
+        a[5] === b[5]);
+}
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export function equals(a, b) {
+    const [a0, a1, a2, a3, a4, a5] = a;
+    const [b0, b1, b2, b3, b4, b5] = b;
+    return (Math.abs(a0 - b0) <=
+        Common.EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) &&
+        Math.abs(a1 - b1) <=
+            Common.EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) &&
+        Math.abs(a2 - b2) <=
+            Common.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2)) &&
+        Math.abs(a3 - b3) <=
+            Common.EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3)) &&
+        Math.abs(a4 - b4) <=
+            Common.EPSILON * Math.max(1, Math.abs(a4), Math.abs(b4)) &&
+        Math.abs(a5 - b5) <=
+            Common.EPSILON * Math.max(1, Math.abs(a5), Math.abs(b5)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mat2d.js","sourceRoot":"","sources":["../../src/mat2d.ts"],"names":[],"mappings":"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"}

package/lib/esm/mat3.d.ts

@@ -0,0 +1,120 @@
+import { Mat4 } from './mat4';
+import { Quat } from './quat';
+import { Vec2 } from './vec2';
+import { Vec3 } from './vec3';
+export type Mat3 = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare function of(m00: number, m01: number, m02: number, m10: number, m11: number, m12: number, m20: number, m21: number, m22: number): Mat3;
+/**
+ * 3x3 Matrix
+ * @module mat3
+ */
+/**
+ * Copies the upper-left 3x3 values into the given mat3.
+ */
+export declare function fromMat4(a: Mat4): Mat3;
+/**
+ * The identity matrix of mat3
+ */
+export declare const identity: readonly number[];
+export declare const zero: Mat3;
+/**
+ * Transpose the values of a mat3
+ */
+export declare function transpose(a: Mat3): Mat3;
+/**
+ * Inverts a mat3
+ */
+export declare function invert(a: Mat3): Mat3 | null;
+/**
+ * Calculates the adjugate of a mat3
+ */
+export declare function adjoint(a: Mat3): Mat3;
+/**
+ * Calculates the determinant of a mat3
+ */
+export declare function determinant(a: Mat3): number;
+/**
+ * Multiplies two mat3's
+ */
+export declare function multiply(a: Mat3, b: Mat3): Mat3;
+/**
+ * Translate a mat3 by the given vector
+ */
+export declare function translate(a: Mat3, v: Vec3): Mat3;
+/**
+ * Rotates a mat3 by the given angle
+ */
+export declare function rotate(a: Mat3, rad: number): Mat3;
+/**
+ * Scales the mat3 by the dimensions in the given vec2
+ **/
+export declare function scale(a: Mat3, v: Vec2): Mat3;
+/**
+ * Creates a matrix from a vector translation
+ */
+export declare function fromTranslation(v: Vec2): Mat3;
+/**
+ * Creates a matrix from a given angle
+ */
+export declare function fromRotation(rad: number): Mat3;
+/**
+ * Creates a matrix from a vector scaling
+ */
+export declare function fromScaling(v: Vec2): Mat3;
+/**
+ * Copies the values from a mat2d into a mat3
+ **/
+export declare function fromMat2d(a: Mat3): Mat3;
+/**
+ * Calculates a 3x3 matrix from the given quaternion
+ *
+ */
+export declare function fromQuat(q: Quat): Mat3;
+/**
+ * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
+ *
+ */
+export declare function normalFromMat4(a: Mat4): Mat3 | null;
+/**
+ * Generates a 2D projection matrix with the given bounds
+ */
+export declare function projection(width: number, height: number): Mat3;
+/**
+ * Returns Frobenius norm of a mat3
+ */
+export declare function frob(a: Mat3): number;
+/**
+ * Adds two mat3's
+ */
+export declare function add(a: Mat3, b: Mat3): Mat3;
+/**
+ * Subtracts matrix b from matrix a
+ */
+export declare function subtract(a: Mat3, b: Mat3): Mat3;
+/**
+ * Multiply each element of the matrix by a scalar.
+ */
+export declare function multiplyScalar(a: Mat3, s: number): Mat3;
+/**
+ * Adds two mat3's after multiplying each element of the second operand by a scalar value.
+ */
+export declare function multiplyScalarAndAdd(a: Mat3, b: Mat3, scale: number): Mat3;
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
+ */
+export declare function exactEquals(a: Mat3, b: Mat3): boolean;
+/**
+ * Returns whether or not the matrices have approximately the same elements in the same position.
+ */
+export declare function equals(a: Mat3, b: Mat3): boolean;
+//# sourceMappingURL=mat3.d.ts.map

package/lib/esm/mat3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mat3.d.ts","sourceRoot":"","sources":["../../src/mat3.ts"],"names":[],"mappings":"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"}