curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/interval2d-C2id9u31.d.mts

@@ -0,0 +1,172 @@
+import { t as Vector2 } from "./vector2-DPUY3_eA.mjs";
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+import { n as Closed, r as Interval, t as Bounds } from "./interval-Dy-RMEE3.mjs";
+
+//#region src/interval/interval2d.internal.d.ts
+declare const Interval2dTypeId: unique symbol;
+type Interval2dTypeId = typeof Interval2dTypeId;
+declare namespace interval2d_d_exports {
+  export { Bounds2d, Interval2d, containsInterval2d, containsVector, equals, fromCorners, fromVectors, isInterval2d, make, size, union };
+}
+/**
+ * An axis-aligned 2D interval — the Cartesian product of two 1D intervals.
+ * Used as a bounding box for curves and paths, and as a region for
+ * containment tests.
+ *
+ * The two type parameters carry the per-axis interval subtype so that a value
+ * built from closed intervals stays `Interval2d<Closed, Closed>` and a value
+ * with mixed openness preserves that information at the type level.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 2.1.0
+ */
+interface Interval2d<X extends Interval = Interval, Y extends Interval = Interval> extends Pipeable {
+  readonly [Interval2dTypeId]: Interval2dTypeId;
+  readonly x: X;
+  readonly y: Y;
+}
+/**
+ * The structural minimum: any value with `x` and `y` fields shaped like
+ * {@link Bounds}. Operations that don't read endpoint inclusivity (e.g.
+ * {@link size}) accept `Bounds2d` so the signature itself documents what the
+ * operation depends on. Mirrors the {@link Bounds}/{@link Interval} split in 1D.
+ *
+ * @since 2.1.0
+ */
+interface Bounds2d {
+  readonly x: Bounds;
+  readonly y: Bounds;
+}
+/**
+ * Checks if a value is an `Interval2d`.
+ *
+ * @param v - The value to check.
+ * @returns `true` if the value is an `Interval2d`, `false` otherwise.
+ * @since 2.1.0
+ */
+declare const isInterval2d: (v: unknown) => v is Interval2d;
+/**
+ * Creates a new `Interval2d` from two intervals — one for the x axis, one
+ * for the y axis. Preserves both interval subtypes at the type level.
+ *
+ * @param x - The x-axis interval.
+ * @param y - The y-axis interval.
+ * @returns A new `Interval2d` instance.
+ * @since 2.1.0
+ */
+declare const make: <X extends Interval, Y extends Interval>(x: X, y: Y) => Interval2d<X, Y>;
+/**
+ * Creates a closed `Interval2d` from two corner points. The corners can be in
+ * any order — each axis is built from the min and max of the coordinate.
+ *
+ * @param p0 - The first corner.
+ * @param p1 - The second corner.
+ * @returns A new `Interval2d<Closed, Closed>` enclosing both corners.
+ * @since 2.1.0
+ */
+declare const fromCorners: (p0: Vector2, p1: Vector2) => Interval2d<Closed, Closed>;
+/**
+ * Creates the smallest closed `Interval2d` enclosing the given points. Useful
+ * for computing a bounding box from sampled points.
+ *
+ * @param points - One or more points to enclose.
+ * @returns A new `Interval2d<Closed, Closed>` enclosing all input points.
+ * @throws When called with zero points.
+ * @since 2.1.0
+ */
+declare const fromVectors: (...points: ReadonlyArray<Vector2>) => Interval2d<Closed, Closed>;
+declare const containsVector: {
+  /**
+   * Checks if a vector lies within the 2D interval. Per-axis endpoint
+   * inclusivity follows each axis interval's `kind`.
+   *
+   * @param box - The 2D interval to test against.
+   * @param v - The vector to test.
+   * @returns `true` when the vector lies within the box on both axes.
+   * @since 2.1.0
+   */
+  (box: Interval2d, v: Vector2): boolean;
+  /**
+   * @param v - The vector to test.
+   * @returns A function that takes a 2D interval and returns the containment result.
+   * @since 2.1.0
+   */
+  (v: Vector2): (box: Interval2d) => boolean;
+};
+declare const containsInterval2d: {
+  /**
+   * Checks if `inner` is a subset of `outer`. The check is per-axis interval
+   * containment — for each axis, every point of the inner interval must also
+   * be in the outer interval, respecting endpoint inclusivity on both sides.
+   *
+   * @param outer - The enclosing 2D interval.
+   * @param inner - The candidate inner 2D interval.
+   * @returns `true` when every point of `inner` is also in `outer`.
+   * @since 2.1.0
+   */
+  (outer: Interval2d, inner: Interval2d): boolean;
+  /**
+   * @param inner - The candidate inner 2D interval.
+   * @returns A function that takes the outer 2D interval and returns the containment result.
+   * @since 2.1.0
+   */
+  (inner: Interval2d): (outer: Interval2d) => boolean;
+};
+/**
+ * Returns the size as a vector `(width, height)`. Accepts the broader
+ * {@link Bounds2d} type because size does not depend on endpoint inclusivity.
+ *
+ * @param box - The 2D interval (or bounds-shaped value) to measure.
+ * @returns The size as a `Vector2`.
+ * @since 2.1.0
+ */
+declare const size: (box: Bounds2d) => Vector2;
+declare const union: {
+  /**
+   * Returns the smallest 2D interval enclosing both inputs.
+   *
+   * The per-axis return kind is determined by which input's endpoint wins on
+   * each side, with the contributor's openness preserved (or unioned to
+   * "closed" when endpoints are numerically equal and either is closed at
+   * that point).
+   *
+   * When both inputs share the same kind on an axis, the result collapses
+   * back to that kind. Otherwise the axis falls back to the open
+   * {@link Interval} type since the runtime kind depends on the values.
+   *
+   * @param a - The first 2D interval.
+   * @param b - The second 2D interval.
+   * @returns A new `Interval2d` enclosing both inputs.
+   * @since 2.1.0
+   */
+  <AX extends Interval, AY extends Interval, BX extends Interval, BY extends Interval>(a: Interval2d<AX, AY>, b: Interval2d<BX, BY>): Interval2d<AX extends BX ? (BX extends AX ? AX : Interval) : Interval, AY extends BY ? (BY extends AY ? AY : Interval) : Interval>;
+  /**
+   * @param b - The second 2D interval.
+   * @returns A function that takes the first 2D interval and returns the union.
+   * @since 2.1.0
+   */
+  <BX extends Interval, BY extends Interval>(b: Interval2d<BX, BY>): <AX extends Interval, AY extends Interval>(a: Interval2d<AX, AY>) => Interval2d<AX extends BX ? (BX extends AX ? AX : Interval) : Interval, AY extends BY ? (BY extends AY ? AY : Interval) : Interval>;
+};
+declare const equals: {
+  /**
+   * Checks if two `Interval2d` values are approximately equal within the
+   * default absolute tolerance ({@link EPSILON}). Both the numeric endpoints
+   * AND the per-axis kinds must match.
+   *
+   * @param a - The first 2D interval.
+   * @param b - The second 2D interval.
+   * @returns `true` when both axes are equal.
+   * @since 2.1.0
+   */
+  (a: Interval2d, b: Interval2d): boolean;
+  /**
+   * @param b - The second 2D interval.
+   * @returns A function that takes the first 2D interval and returns the comparison result.
+   * @since 2.1.0
+   */
+  (b: Interval2d): (a: Interval2d) => boolean;
+};
+//#endregion
+export { interval2d_d_exports as n, Interval2d as t };
+//# sourceMappingURL=interval2d-C2id9u31.d.mts.map

package/dist/shared/matrix4x4-Ck2WROK-.mjs

@@ -0,0 +1,440 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { epsEquals } from "../number.mjs";
+import { i as dot, m as make$4 } from "./vector2.internal-DU_E808S.mjs";
+import { O as make$5, _ as dot$1, c as make$6, h as components, n as components$1, r as dot$2 } from "./vector4.internal-5XcaX12X.mjs";
+//#region src/dimensions.ts
+function toIndex(input) {
+	if (typeof input === "number") {
+		invariant(input >= 0 && input <= 3, "Index out of bounds");
+		return input;
+	}
+	if (input === "x") return 0;
+	if (input === "y") return 1;
+	if (input === "z") return 2;
+	if (input === "w") return 3;
+	invariant(false, "Invalid component");
+}
+const toTwoDimensionalIndex = toIndex;
+const toThreeDimensionalIndex = toIndex;
+const toFourDimensionalIndex = toIndex;
+//#endregion
+//#region src/matrix/matrix2x2.internal.ts
+const Matrix2x2TypeId = Symbol.for("curvy/matrix2x2");
+var Matrix2x2Impl = class extends Pipeable {
+	[Matrix2x2TypeId] = Matrix2x2TypeId;
+	m00;
+	m01;
+	m10;
+	m11;
+	constructor(m00 = 0, m01 = 0, m10 = 0, m11 = 0) {
+		super();
+		this.m00 = m00;
+		this.m01 = m01;
+		this.m10 = m10;
+		this.m11 = m11;
+	}
+	get [Symbol.toStringTag]() {
+		return `Matrix2x2(${this.m00}, ${this.m01}, ${this.m10}, ${this.m11})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return `Matrix2x2(${this.m00}, ${this.m01}, ${this.m10}, ${this.m11})`;
+	}
+	[Symbol.hasInstance](m) {
+		return isMatrix2x2(m);
+	}
+};
+const isMatrix2x2 = (m) => typeof m === "object" && m !== null && Matrix2x2TypeId in m;
+const equals$3 = dual(2, (a, b) => epsEquals(a.m00, b.m00) && epsEquals(a.m01, b.m01) && epsEquals(a.m10, b.m10) && epsEquals(a.m11, b.m11));
+const make$3 = (m00 = 0, m01 = m00, m10 = m01, m11 = m10) => new Matrix2x2Impl(m00, m01, m10, m11);
+const fromRows$3 = (v0, v1) => new Matrix2x2Impl(v0.x, v0.y, v1.x, v1.y);
+const fromColumns$3 = (v0, v1) => new Matrix2x2Impl(v0.x, v1.x, v0.y, v1.y);
+const setRow$3 = dual(3, (m, row, v) => fromRows$3(...toRows$3(m).with(toTwoDimensionalIndex(row), v)));
+const setColumn$3 = dual(3, (m, column, v) => fromColumns$3(...toColumns$3(m).with(toTwoDimensionalIndex(column), v)));
+const determinant$3 = (m) => m.m00 * m.m11 - m.m01 * m.m10;
+const vectorProductLeft$3 = dual(2, (m, v) => make$4(dot(rowVector$3(m, 0), v), dot(rowVector$3(m, 1), v)));
+const vectorProductRight$3 = dual(2, (m, v) => make$4(dot(columnVector$3(m, 0), v), dot(columnVector$3(m, 1), v)));
+const solveSystem$3 = dual(2, (m, v) => {
+	const inverseDeterminant = 1 / determinant$3(m);
+	invariant(Number.isFinite(inverseDeterminant), "cannot solve system when coefficient matrix determinant is zero");
+	return make$4(determinant$3(setColumn$3(m, 0, v)) * inverseDeterminant, determinant$3(setColumn$3(m, 1, v)) * inverseDeterminant);
+});
+const toRows$3 = (m) => [make$4(m.m00, m.m01), make$4(m.m10, m.m11)];
+const toColumns$3 = (m) => [make$4(m.m00, m.m10), make$4(m.m01, m.m11)];
+const rowVector$3 = dual(2, (m, row) => toRows$3(m)[toTwoDimensionalIndex(row)]);
+const columnVector$3 = dual(2, (m, column) => toColumns$3(m)[toTwoDimensionalIndex(column)]);
+const transpose$3 = (m) => fromColumns$3(...toRows$3(m));
+const reverseRows$3 = (m) => {
+	const [r0, r1] = toRows$3(m);
+	return fromRows$3(r1, r0);
+};
+const reverseColumns$3 = (m) => {
+	const [c0, c1] = toColumns$3(m);
+	return fromColumns$3(c1, c0);
+};
+//#endregion
+//#region src/matrix/matrix3x3.internal.ts
+const Matrix3x3TypeId = Symbol.for("curvy/matrix3x3");
+var Matrix3x3Impl = class extends Pipeable {
+	[Matrix3x3TypeId] = Matrix3x3TypeId;
+	m00;
+	m01;
+	m02;
+	m10;
+	m11;
+	m12;
+	m20;
+	m21;
+	m22;
+	constructor(m00 = 0, m01 = 0, m02 = 0, m10 = 0, m11 = 0, m12 = 0, m20 = 0, m21 = 0, m22 = 0) {
+		super();
+		this.m00 = m00;
+		this.m01 = m01;
+		this.m02 = m02;
+		this.m10 = m10;
+		this.m11 = m11;
+		this.m12 = m12;
+		this.m20 = m20;
+		this.m21 = m21;
+		this.m22 = m22;
+	}
+	get [Symbol.toStringTag]() {
+		return `Matrix3x3(${this.m00}, ${this.m01}, ${this.m02}, ${this.m10}, ${this.m11}, ${this.m12}, ${this.m20}, ${this.m21}, ${this.m22})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return `Matrix3x3(${this.m00}, ${this.m01}, ${this.m02}, ${this.m10}, ${this.m11}, ${this.m12}, ${this.m20}, ${this.m21}, ${this.m22})`;
+	}
+	[Symbol.hasInstance](m) {
+		return isMatrix3x3(m);
+	}
+};
+const isMatrix3x3 = (m) => typeof m === "object" && m !== null && Matrix3x3TypeId in m;
+const equals$2 = dual(2, (a, b) => epsEquals(a.m00, b.m00) && epsEquals(a.m01, b.m01) && epsEquals(a.m02, b.m02) && epsEquals(a.m10, b.m10) && epsEquals(a.m11, b.m11) && epsEquals(a.m12, b.m12) && epsEquals(a.m20, b.m20) && epsEquals(a.m21, b.m21) && epsEquals(a.m22, b.m22));
+const make$2 = (m00 = 0, m01 = m00, m02 = m01, m10 = m02, m11 = m10, m12 = m11, m20 = m12, m21 = m20, m22 = m21) => {
+	return new Matrix3x3Impl(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+};
+const fromRows$2 = (v0, v1, v2) => new Matrix3x3Impl(v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z);
+const fromColumns$2 = (v0, v1, v2) => new Matrix3x3Impl(v0.x, v1.x, v2.x, v0.y, v1.y, v2.y, v0.z, v1.z, v2.z);
+const setRow$2 = dual(3, (m, row, v) => fromRows$2(...toRows$2(m).with(toThreeDimensionalIndex(row), v)));
+const setColumn$2 = dual(3, (m, column, v) => fromColumns$2(...toColumns$2(m).with(toThreeDimensionalIndex(column), v)));
+const determinant$2 = (m) => m.m00 * determinant$3(minor$2(m, 0, 0)) - m.m01 * determinant$3(minor$2(m, 0, 1)) + m.m02 * determinant$3(minor$2(m, 0, 2));
+const minor$2 = dual(3, (m, row, column) => {
+	const [v0, v1] = toRows$2(m).toSpliced(toThreeDimensionalIndex(row), 1);
+	const columnIndex = toThreeDimensionalIndex(column);
+	const [m00, m01] = components(v0).toSpliced(columnIndex, 1);
+	const [m10, m11] = components(v1).toSpliced(columnIndex, 1);
+	return make$3(m00, m01, m10, m11);
+});
+const vectorProductLeft$2 = dual(2, (m, v) => {
+	const [v0, v1, v2] = toRows$2(m);
+	return make$5(dot$1(v0, v), dot$1(v1, v), dot$1(v2, v));
+});
+const vectorProductRight$2 = dual(2, (m, v) => {
+	const [v0, v1, v2] = toColumns$2(m);
+	return make$5(dot$1(v, v0), dot$1(v, v1), dot$1(v, v2));
+});
+const solveSystem$2 = dual(2, (m, v) => {
+	const inverseDeterminant = 1 / determinant$2(m);
+	invariant(Number.isFinite(inverseDeterminant), "cannot solve system when coefficient matrix determinant is zero");
+	return make$5(determinant$2(setColumn$2(m, 0, v)) * inverseDeterminant, determinant$2(setColumn$2(m, 1, v)) * inverseDeterminant, determinant$2(setColumn$2(m, 2, v)) * inverseDeterminant);
+});
+const toRows$2 = (m) => [
+	make$5(m.m00, m.m01, m.m02),
+	make$5(m.m10, m.m11, m.m12),
+	make$5(m.m20, m.m21, m.m22)
+];
+const toColumns$2 = (m) => [
+	make$5(m.m00, m.m10, m.m20),
+	make$5(m.m01, m.m11, m.m21),
+	make$5(m.m02, m.m12, m.m22)
+];
+const rowVector$2 = dual(2, (m, row) => toRows$2(m)[toThreeDimensionalIndex(row)]);
+const columnVector$2 = dual(2, (m, column) => toColumns$2(m)[toThreeDimensionalIndex(column)]);
+const transpose$2 = (m) => fromColumns$2(...toRows$2(m));
+const reverseRows$2 = (m) => {
+	const [v0, v1, v2] = toRows$2(m);
+	return fromRows$2(v2, v1, v0);
+};
+const reverseColumns$2 = (m) => {
+	const [v0, v1, v2] = toColumns$2(m);
+	return fromColumns$2(v2, v1, v0);
+};
+//#endregion
+//#region src/matrix/matrix4x4.internal.ts
+const Matrix4x4TypeId = Symbol.for("curvy/matrix4x4");
+var Matrix4x4Impl = class extends Pipeable {
+	[Matrix4x4TypeId] = Matrix4x4TypeId;
+	m00;
+	m01;
+	m02;
+	m03;
+	m10;
+	m11;
+	m12;
+	m13;
+	m20;
+	m21;
+	m22;
+	m23;
+	m30;
+	m31;
+	m32;
+	m33;
+	constructor(m00 = 0, m01 = m00, m02 = m01, m03 = m02, m10 = m00, m11 = m01, m12 = m02, m13 = m03, m20 = m00, m21 = m01, m22 = m02, m23 = m03, m30 = m00, m31 = m01, m32 = m02, m33 = m03) {
+		super();
+		this.m00 = m00;
+		this.m01 = m01;
+		this.m02 = m02;
+		this.m03 = m03;
+		this.m10 = m10;
+		this.m11 = m11;
+		this.m12 = m12;
+		this.m13 = m13;
+		this.m20 = m20;
+		this.m21 = m21;
+		this.m22 = m22;
+		this.m23 = m23;
+		this.m30 = m30;
+		this.m31 = m31;
+		this.m32 = m32;
+		this.m33 = m33;
+	}
+	get [Symbol.toStringTag]() {
+		return `Matrix4x4(${this.m00}, ${this.m01}, ${this.m02}, ${this.m03}, ${this.m10}, ${this.m11}, ${this.m12}, ${this.m13}, ${this.m20}, ${this.m21}, ${this.m22}, ${this.m23}, ${this.m30}, ${this.m31}, ${this.m32}, ${this.m33})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return `Matrix4x4(${this.m00}, ${this.m01}, ${this.m02}, ${this.m03}, ${this.m10}, ${this.m11}, ${this.m12}, ${this.m13}, ${this.m20}, ${this.m21}, ${this.m22}, ${this.m23}, ${this.m30}, ${this.m31}, ${this.m32}, ${this.m33})`;
+	}
+	[Symbol.hasInstance](m) {
+		return isMatrix4x4$1(m);
+	}
+};
+const isMatrix4x4$1 = (m) => typeof m === "object" && m !== null && Matrix4x4TypeId in m;
+const equals$1 = dual(2, (a, b) => epsEquals(a.m00, b.m00) && epsEquals(a.m01, b.m01) && epsEquals(a.m02, b.m02) && epsEquals(a.m03, b.m03) && epsEquals(a.m10, b.m10) && epsEquals(a.m11, b.m11) && epsEquals(a.m12, b.m12) && epsEquals(a.m13, b.m13) && epsEquals(a.m20, b.m20) && epsEquals(a.m21, b.m21) && epsEquals(a.m22, b.m22) && epsEquals(a.m23, b.m23) && epsEquals(a.m30, b.m30) && epsEquals(a.m31, b.m31) && epsEquals(a.m32, b.m32) && epsEquals(a.m33, b.m33));
+/**
+* The 4x4 identity matrix.
+*/
+const identity$1 = new Matrix4x4Impl(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+const make$1 = (m00 = 0, m01 = m00, m02 = m01, m03 = m02, m10 = m00, m11 = m01, m12 = m02, m13 = m03, m20 = m00, m21 = m01, m22 = m02, m23 = m03, m30 = m00, m31 = m01, m32 = m02, m33 = m03) => new Matrix4x4Impl(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33);
+const fromRows$1 = (v0, v1, v2, v3) => new Matrix4x4Impl(v0.x, v0.y, v0.z, v0.w, v1.x, v1.y, v1.z, v1.w, v2.x, v2.y, v2.z, v2.w, v3.x, v3.y, v3.z, v3.w);
+const fromColumns$1 = (v0, v1, v2, v3) => new Matrix4x4Impl(v0.x, v1.x, v2.x, v3.x, v0.y, v1.y, v2.y, v3.y, v0.z, v1.z, v2.z, v3.z, v0.w, v1.w, v2.w, v3.w);
+const setRow$1 = dual(3, (m, row, v) => fromRows$1(...toRows$1(m).with(toFourDimensionalIndex(row), v)));
+const setColumn$1 = dual(3, (m, column, v) => fromColumns$1(...toColumns$1(m).with(toFourDimensionalIndex(column), v)));
+const determinant$1 = (m) => m.m00 * determinant$2(minor$1(m, 0, 0)) - m.m01 * determinant$2(minor$1(m, 0, 1)) + m.m02 * determinant$2(minor$1(m, 0, 2)) - m.m03 * determinant$2(minor$1(m, 0, 3));
+const minor$1 = dual(3, (m, row, column) => {
+	const [v0, v1, v2] = toRows$1(m).toSpliced(toFourDimensionalIndex(row), 1);
+	const columnIndex = toFourDimensionalIndex(column);
+	const [m00, m01, m02] = components$1(v0).toSpliced(columnIndex, 1);
+	const [m10, m11, m12] = components$1(v1).toSpliced(columnIndex, 1);
+	const [m20, m21, m22] = components$1(v2).toSpliced(columnIndex, 1);
+	return make$2(m00, m01, m02, m10, m11, m12, m20, m21, m22);
+});
+const vectorProductLeft$1 = dual(2, (m, v) => {
+	const [v0, v1, v2, v3] = toRows$1(m);
+	return make$6(dot$2(v0, v), dot$2(v1, v), dot$2(v2, v), dot$2(v3, v));
+});
+const vectorProductRight$1 = dual(2, (m, v) => {
+	const [v0, v1, v2, v3] = toColumns$1(m);
+	return make$6(dot$2(v, v0), dot$2(v, v1), dot$2(v, v2), dot$2(v, v3));
+});
+const multiply$1 = dual(2, (a, b) => new Matrix4x4Impl(a.m00 * b.m00 + a.m01 * b.m10 + a.m02 * b.m20 + a.m03 * b.m30, a.m00 * b.m01 + a.m01 * b.m11 + a.m02 * b.m21 + a.m03 * b.m31, a.m00 * b.m02 + a.m01 * b.m12 + a.m02 * b.m22 + a.m03 * b.m32, a.m00 * b.m03 + a.m01 * b.m13 + a.m02 * b.m23 + a.m03 * b.m33, a.m10 * b.m00 + a.m11 * b.m10 + a.m12 * b.m20 + a.m13 * b.m30, a.m10 * b.m01 + a.m11 * b.m11 + a.m12 * b.m21 + a.m13 * b.m31, a.m10 * b.m02 + a.m11 * b.m12 + a.m12 * b.m22 + a.m13 * b.m32, a.m10 * b.m03 + a.m11 * b.m13 + a.m12 * b.m23 + a.m13 * b.m33, a.m20 * b.m00 + a.m21 * b.m10 + a.m22 * b.m20 + a.m23 * b.m30, a.m20 * b.m01 + a.m21 * b.m11 + a.m22 * b.m21 + a.m23 * b.m31, a.m20 * b.m02 + a.m21 * b.m12 + a.m22 * b.m22 + a.m23 * b.m32, a.m20 * b.m03 + a.m21 * b.m13 + a.m22 * b.m23 + a.m23 * b.m33, a.m30 * b.m00 + a.m31 * b.m10 + a.m32 * b.m20 + a.m33 * b.m30, a.m30 * b.m01 + a.m31 * b.m11 + a.m32 * b.m21 + a.m33 * b.m31, a.m30 * b.m02 + a.m31 * b.m12 + a.m32 * b.m22 + a.m33 * b.m32, a.m30 * b.m03 + a.m31 * b.m13 + a.m32 * b.m23 + a.m33 * b.m33));
+const inverse$1 = (m) => {
+	const det = determinant$1(m);
+	invariant(det !== 0, "cannot invert singular matrix");
+	const inv = 1 / det;
+	const cof = (row, col) => {
+		return ((row + col) % 2 === 0 ? 1 : -1) * determinant$2(minor$1(m, row, col)) * inv;
+	};
+	return new Matrix4x4Impl(cof(0, 0), cof(1, 0), cof(2, 0), cof(3, 0), cof(0, 1), cof(1, 1), cof(2, 1), cof(3, 1), cof(0, 2), cof(1, 2), cof(2, 2), cof(3, 2), cof(0, 3), cof(1, 3), cof(2, 3), cof(3, 3));
+};
+const solveSystem$1 = dual(2, (m, v) => {
+	const inverseDeterminant = 1 / determinant$1(m);
+	invariant(Number.isFinite(inverseDeterminant), "cannot solve system when coefficient matrix determinant is zero");
+	return make$6(determinant$1(setColumn$1(m, 0, v)) * inverseDeterminant, determinant$1(setColumn$1(m, 1, v)) * inverseDeterminant, determinant$1(setColumn$1(m, 2, v)) * inverseDeterminant, determinant$1(setColumn$1(m, 3, v)) * inverseDeterminant);
+});
+const toRows$1 = (m) => [
+	make$6(m.m00, m.m01, m.m02, m.m03),
+	make$6(m.m10, m.m11, m.m12, m.m13),
+	make$6(m.m20, m.m21, m.m22, m.m23),
+	make$6(m.m30, m.m31, m.m32, m.m33)
+];
+const toColumns$1 = (m) => [
+	make$6(m.m00, m.m10, m.m20, m.m30),
+	make$6(m.m01, m.m11, m.m21, m.m31),
+	make$6(m.m02, m.m12, m.m22, m.m32),
+	make$6(m.m03, m.m13, m.m23, m.m33)
+];
+const rowVector$1 = dual(2, (m, row) => toRows$1(m)[toFourDimensionalIndex(row)]);
+const columnVector$1 = dual(2, (m, column) => toColumns$1(m)[toFourDimensionalIndex(column)]);
+const transpose$1 = (m) => fromColumns$1(...toRows$1(m));
+const reverseRows$1 = (m) => {
+	const [v0, v1, v2, v3] = toRows$1(m);
+	return fromRows$1(v3, v2, v1, v0);
+};
+const reverseColumns$1 = (m) => {
+	const [v0, v1, v2, v3] = toColumns$1(m);
+	return fromColumns$1(v3, v2, v1, v0);
+};
+//#endregion
+//#region src/matrix/matrix4x4.ts
+var matrix4x4_exports = /* @__PURE__ */ __exportAll({
+	columnVector: () => columnVector,
+	determinant: () => determinant,
+	equals: () => equals,
+	fromColumns: () => fromColumns,
+	fromRows: () => fromRows,
+	identity: () => identity,
+	inverse: () => inverse,
+	isMatrix4x4: () => isMatrix4x4,
+	make: () => make,
+	minor: () => minor,
+	multiply: () => multiply,
+	reverseColumns: () => reverseColumns,
+	reverseRows: () => reverseRows,
+	rowVector: () => rowVector,
+	setColumn: () => setColumn,
+	setRow: () => setRow,
+	solveSystem: () => solveSystem,
+	toColumns: () => toColumns,
+	toRows: () => toRows,
+	transpose: () => transpose,
+	vectorProductLeft: () => vectorProductLeft,
+	vectorProductRight: () => vectorProductRight
+});
+/**
+* Checks if a value is a `Matrix4x4`.
+*
+* @param m - The value to check.
+* @returns `true` if the value is a `Matrix4x4`, `false` otherwise.
+* @since 1.0.0
+*/
+const isMatrix4x4 = isMatrix4x4$1;
+/**
+* The 4x4 identity matrix.
+*
+* @since 1.1.0
+*/
+const identity = identity$1;
+const equals = equals$1;
+/**
+* Creates a new `Matrix4x4` instance.
+*
+* @param m00 - The value of the first row and first column.
+* @param m01 - The value of the first row and second column.
+* @param m02 - The value of the first row and third column.
+* @param m03 - The value of the first row and fourth column.
+* @param m10 - The value of the second row and first column.
+* @param m11 - The value of the second row and second column.
+* @param m12 - The value of the second row and third column.
+* @param m13 - The value of the second row and fourth column.
+* @param m20 - The value of the third row and first column.
+* @param m21 - The value of the third row and second column.
+* @param m22 - The value of the third row and third column.
+* @param m23 - The value of the third row and fourth column.
+* @param m30 - The value of the fourth row and first column.
+* @param m31 - The value of the fourth row and second column.
+* @param m32 - The value of the fourth row and third column.
+* @param m33 - The value of the fourth row and fourth column.
+* @returns A new `Matrix4x4` instance.
+* @since 1.0.0
+*/
+const make = make$1;
+/**
+* Creates a new `Matrix4x4` instance from four row vectors.
+*
+* @param v0 - The first row vector.
+* @param v1 - The second row vector.
+* @param v2 - The third row vector.
+* @param v3 - The fourth row vector.
+* @returns A new `Matrix4x4` instance.
+* @since 1.0.0
+*/
+const fromRows = fromRows$1;
+/**
+* Creates a new `Matrix4x4` instance from four column vectors.
+*
+* @param v0 - The first column vector.
+* @param v1 - The second column vector.
+* @param v2 - The third column vector.
+* @param v3 - The fourth column vector.
+*/
+const fromColumns = fromColumns$1;
+const setRow = setRow$1;
+const setColumn = setColumn$1;
+/**
+* Calculates the determinant of a `Matrix4x4`.
+*
+* @param m - The matrix to calculate the determinant of.
+* @returns The determinant of the matrix.
+* @since 1.0.0
+*/
+const determinant = determinant$1;
+/**
+* Calculates the minor of a `Matrix4x4` at a given row and column.
+*
+* @param m - The matrix to calculate the minor of.
+* @param row - The row to exclude.
+* @param column - The column to exclude.
+* @returns The minor of the matrix at the given row and column.
+*/
+const minor = minor$1;
+const vectorProductLeft = vectorProductLeft$1;
+const vectorProductRight = vectorProductRight$1;
+const multiply = multiply$1;
+/**
+* Returns the inverse of a `Matrix4x4`.
+*
+* Throws when the matrix is singular (determinant is zero).
+*
+* @param m - The matrix to invert.
+* @returns The inverse matrix.
+* @since 1.1.0
+*/
+const inverse = inverse$1;
+const solveSystem = solveSystem$1;
+/**
+* Returns the rows of a `Matrix4x4` as an array of vectors.
+*
+* @param m - The matrix to convert.
+* @returns An array of vectors representing the rows of the matrix.
+* @since 1.0.0
+*/
+const toRows = toRows$1;
+/**
+* Returns the columns of a `Matrix4x4` as an array of vectors.
+*
+* @param m - The matrix to convert.
+* @returns An array of vectors representing the columns of the matrix.
+* @since 1.0.0
+*/
+const toColumns = toColumns$1;
+const rowVector = rowVector$1;
+const columnVector = columnVector$1;
+/**
+* Transposes a `Matrix4x4`.
+*
+* @param m - The matrix to transpose.
+* @returns The transposed matrix.
+* @since 1.0.0
+*/
+const transpose = transpose$1;
+/**
+* Reverses the rows of a `Matrix4x4`.
+*
+* @param m - The matrix to reverse the rows of.
+* @returns The matrix with the rows reversed.
+* @since 1.0.0
+*/
+const reverseRows = reverseRows$1;
+/**
+* Reverses the columns of a `Matrix4x4`.
+*
+* @param m - The matrix to reverse the columns of.
+* @returns The matrix with the columns reversed.
+* @since 1.0.0
+*/
+const reverseColumns = reverseColumns$1;
+//#endregion
+export { isMatrix2x2 as A, transpose$3 as B, vectorProductLeft$2 as C, equals$3 as D, determinant$3 as E, setColumn$3 as F, vectorProductRight$3 as H, setRow$3 as I, solveSystem$3 as L, reverseColumns$3 as M, reverseRows$3 as N, fromColumns$3 as O, rowVector$3 as P, toColumns$3 as R, transpose$2 as S, columnVector$3 as T, vectorProductLeft$3 as V, setColumn$2 as _, vectorProductLeft as a, toColumns$2 as b, equals$2 as c, isMatrix3x3 as d, make$2 as f, rowVector$2 as g, reverseRows$2 as h, multiply as i, make$3 as j, fromRows$3 as k, fromColumns$2 as l, reverseColumns$2 as m, make as n, columnVector$2 as o, minor$2 as p, matrix4x4_exports as r, determinant$2 as s, inverse as t, fromRows$2 as u, setRow$2 as v, vectorProductRight$2 as w, toRows$2 as x, solveSystem$2 as y, toRows$3 as z };
+
+//# sourceMappingURL=matrix4x4-Ck2WROK-.mjs.map