curvy 2.0.0-alpha.5 → 2.0.0-alpha.7

package/dist/characteristic/characteristic.d.ts

@@ -1,6 +1,6 @@
-import * as Matrix4x4 from '../matrix/matrix4x4';
-import * as CubicPolynomial from '../polynomial/cubic';
-import type * as Vector4 from '../vector/vector4';
+import * as Matrix4x4 from '../matrix/matrix4x4.ts';
+import * as CubicPolynomial from '../polynomial/cubic.ts';
+import type * as Vector4 from '../vector/vector4.ts';
 /**
  * The cubic Bézier characteristic matrix.
  *

package/dist/characteristic/index.d.ts

@@ -1 +1 @@
-export * as Characteristic from './characteristic';
+export * as Characteristic from './characteristic.ts';

package/dist/characteristic/index.mjs

@@ -1,2 +1,2 @@
-import { n as characteristic_exports } from "../shared/characteristic-DLlhja-I.mjs";
+import { n as characteristic_exports } from "../shared/characteristic-D9yZWCym.mjs";
 export { characteristic_exports as Characteristic };

package/dist/curve/cubic2d.d.ts

@@ -1,17 +1,13 @@
-import type { Interval2d } from '../interval/interval2d';
-import type { TwoDimensional } from '../dimensions';
-import type { Closed, Interval } from '../interval/interval';
-import type { Pipeable } from '../utils';
-import type { CubicPolynomial } from '../polynomial/cubic';
-import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits';
-import type * as Solution from '../solution/solution';
-import type { Vector2 } from '../vector/vector2';
-
-declare const CubicCurve2dTypeId: unique symbol;
-type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;
-
-
-export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { TwoDimensional } from '../dimensions.ts';
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Pipeable } from '../utils.ts';
+import type { CubicPolynomial } from '../polynomial/cubic.ts';
+import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { CubicCurve2dTypeId } from './cubic2d.internal.ts';
+export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
  * A cubic curve in 2D space.
  *

package/dist/curve/cubic2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const CubicCurve2dTypeId: unique symbol;
+export type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;

package/dist/curve/index.d.ts

@@ -1,12 +1,12 @@
-import * as LinearCurve2dNs from './linear2d';
-import * as QuadraticCurve2dNs from './quadratic2d';
-import * as CubicCurve2dNs from './cubic2d';
-import * as RationalCubicCurve2dNs from './rationalCubic2d';
+import * as LinearCurve2dNs from './linear2d.ts';
+import * as QuadraticCurve2dNs from './quadratic2d.ts';
+import * as CubicCurve2dNs from './cubic2d.ts';
+import * as RationalCubicCurve2dNs from './rationalCubic2d.ts';
+export type LinearCurve2d<XTraits = unknown, YTraits = unknown> = LinearCurve2dNs.LinearCurve2d<XTraits, YTraits>;
 export { LinearCurve2dNs as LinearCurve2d };
-export type LinearCurve2d = LinearCurve2dNs.LinearCurve2d;
+export type QuadraticCurve2d<XTraits = unknown, YTraits = unknown> = QuadraticCurve2dNs.QuadraticCurve2d<XTraits, YTraits>;
 export { QuadraticCurve2dNs as QuadraticCurve2d };
-export type QuadraticCurve2d = QuadraticCurve2dNs.QuadraticCurve2d;
+export type CubicCurve2d<XTraits = unknown, YTraits = unknown> = CubicCurve2dNs.CubicCurve2d<XTraits, YTraits>;
 export { CubicCurve2dNs as CubicCurve2d };
-export type CubicCurve2d = CubicCurve2dNs.CubicCurve2d;
+export type RationalCubicCurve2d<XTraits = unknown, YTraits = unknown> = RationalCubicCurve2dNs.RationalCubicCurve2d<XTraits, YTraits>;
 export { RationalCubicCurve2dNs as RationalCubicCurve2d };
-export type RationalCubicCurve2d = RationalCubicCurve2dNs.RationalCubicCurve2d;

package/dist/curve/index.mjs

@@ -1,2 +1,2 @@
-import { m as quadratic2d_exports, o as cubic2d_exports, r as rationalCubic2d_exports, v as linear2d_exports } from "../shared/rationalCubic2d-D658ltUM.mjs";
+import { S as linear2d_exports, g as quadratic2d_exports, o as cubic2d_exports, r as rationalCubic2d_exports } from "../shared/rationalCubic2d-DaFTrUXw.mjs";
 export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };

package/dist/curve/linear2d.d.ts

@@ -1,17 +1,13 @@
-import type { Interval2d } from '../interval/interval2d';
-import type { TwoDimensional } from '../dimensions';
-import type { Closed, Interval } from '../interval/interval';
-import type { Pipeable } from '../utils';
-import type { LinearPolynomial } from '../polynomial/linear';
-import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits';
-import type * as Solution from '../solution/solution';
-import type { Vector2 } from '../vector/vector2';
-
-declare const LinearCurve2dTypeId: unique symbol;
-type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;
-
-
-export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { TwoDimensional } from '../dimensions.ts';
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Pipeable } from '../utils.ts';
+import type { LinearPolynomial } from '../polynomial/linear.ts';
+import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { LinearCurve2dTypeId } from './linear2d.internal.ts';
+export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
  * A linear curve in 2D space.
  *
@@ -60,7 +56,7 @@ export declare const fromCoefficients: (c0: Vector2, c1: Vector2) => LinearCurve
  * @returns A new `LinearCurve2d` instance whose curve matches the line from `p0` to `p1`.
  * @since 2.0.0
  */
-export declare const fromBezierPoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
+export declare const fromEndpoints: (p0: Vector2, p1: Vector2) => LinearCurve2d;
 /**
  * Checks if a value is a `LinearCurve2d`.
  *

package/dist/curve/linear2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const LinearCurve2dTypeId: unique symbol;
+export type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;

package/dist/curve/quadratic2d.d.ts

@@ -1,18 +1,14 @@
-import type { Interval2d } from '../interval/interval2d';
-import type { TwoDimensional } from '../dimensions';
-import type { Closed, Interval } from '../interval/interval';
-import type { Pipeable } from '../utils';
-import type { QuadraticPolynomial } from '../polynomial/quadratic';
-import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits';
-import type * as Solution from '../solution/solution';
-import type { Vector2 } from '../vector/vector2';
-import type { LinearCurve2d } from './linear2d';
-
-declare const QuadraticCurve2dTypeId: unique symbol;
-type QuadraticCurve2dTypeId = typeof QuadraticCurve2dTypeId;
-
-
-export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { TwoDimensional } from '../dimensions.ts';
+import type { Closed, Interval } from '../interval/interval.ts';
+import type { Pipeable } from '../utils.ts';
+import type { QuadraticPolynomial } from '../polynomial/quadratic.ts';
+import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { LinearCurve2d } from './linear2d.ts';
+import type { QuadraticCurve2dTypeId } from './quadratic2d.internal.ts';
+export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts';
 /**
  * A quadratic curve in 2D space.
  *

package/dist/curve/quadratic2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const QuadraticCurve2dTypeId: unique symbol;
+export type QuadraticCurve2dTypeId = typeof QuadraticCurve2dTypeId;

package/dist/curve/rationalCubic2d.d.ts

@@ -1,18 +1,14 @@
-import type { Pipeable } from '../utils';
-import type { CubicPolynomial } from '../polynomial/cubic';
-import type { Increasing, Monotonic } from '../polynomial/traits';
-import type * as Solution from '../solution/solution';
-import type { Vector2, Weighted } from '../vector/vector2';
-import type { CubicCurve2d } from './cubic2d';
-
-declare const RationalCubicCurve2dTypeId: unique symbol;
-type RationalCubicCurve2dTypeId = typeof RationalCubicCurve2dTypeId;
-declare const RationalCurveTraits: unique symbol;
-type RationalCurveTraits = typeof RationalCurveTraits;
-
-
-export type { Decreasing, Increasing, Monotonic } from '../polynomial/traits';
-export { RationalCurveTraits } from './rationalCubic2d.internal';
+import type { Closed } from '../interval/interval.ts';
+import type { Interval2d } from '../interval/interval2d.ts';
+import type { Pipeable } from '../utils.ts';
+import type { CubicPolynomial } from '../polynomial/cubic.ts';
+import type { Increasing, Monotonic } from '../polynomial/traits.ts';
+import type * as Solution from '../solution/solution.ts';
+import type { Vector2, Weighted } from '../vector/vector2.ts';
+import type { CubicCurve2d } from './cubic2d.ts';
+import type { RationalCubicCurve2dTypeId, RationalCurveTraits } from './rationalCubic2d.internal.ts';
+export type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+export { RationalCurveTraits } from './rationalCubic2d.internal.ts';
 /**
  * A rational cubic curve in 2D space.
  *
@@ -172,19 +168,64 @@ export declare const solveAtY: {
         <XT, YT>(c: RationalCubicCurve2d<XT, YT>): Solution.AtMostThree<number>;
     };
 };
+export declare const subdivide: {
+    /**
+     * Subdivides a rational cubic curve at parameter `t ∈ (0, 1)` into two new
+     * rational cubic curves. The first curve's evaluation on `[0, 1]` matches
+     * the original's on `[0, t]`; the second matches the original's on `[t, 1]`.
+     * Equivalent to de Casteljau subdivision on the homogeneous control polygon,
+     * but performed directly on the per-axis monomial polynomials.
+     *
+     * @param c - The rational cubic curve to subdivide.
+     * @param t - The split parameter; must be in the open interval `(0, 1)`.
+     * @returns A `[left, right]` tuple of rational cubic curves.
+     * @since 2.0.0
+     */
+    (c: RationalCubicCurve2d, t: number): [RationalCubicCurve2d, RationalCubicCurve2d];
+    /**
+     * Subdivides a rational cubic curve at parameter `t ∈ (0, 1)`.
+     *
+     * @param t - The split parameter; must be in the open interval `(0, 1)`.
+     * @returns A function that takes a curve and returns its `[left, right]` halves.
+     * @since 2.0.0
+     */
+    (t: number): (c: RationalCubicCurve2d) => [RationalCubicCurve2d, RationalCubicCurve2d];
+};
+/**
+ * Computes a closed axis-aligned bounding box for a rational cubic curve from
+ * its projected control polygon. Looser than the tight extrema-based box used
+ * by `CubicCurve2d.boundingBox` — finding tight extrema of `x(t)/w(t)` and
+ * `y(t)/w(t)` requires solving degree-5 polynomials — but always valid: a
+ * positive-weight rational Bézier curve lies inside the convex hull of its
+ * projected control points, so the AABB of those points contains the curve.
+ *
+ * Suitable for subdivision-based geometric queries, where bound looseness is
+ * compensated by recursion depth.
+ *
+ * @param c - The rational cubic curve.
+ * @returns A closed `Interval2d` enclosing the curve.
+ * @since 2.0.0
+ */
+export declare const boundingBox: (c: RationalCubicCurve2d) => Interval2d<Closed, Closed>;
 export declare const approximateAsCubicCurves: {
     /**
      * Approximates the rational cubic as a sequence of polynomial cubic curves
      * via recursive subdivision. At each level a candidate polynomial cubic is
      * built by projecting the segment's homogeneous Bézier control points to
-     * 2D; if the candidate's midpoint deviates from the true rational midpoint
-     * by more than `tolerance`, the segment is split at `t = 0.5` and the
-     * procedure recurses on each half. Returns a non-empty array; for a curve
-     * that is already polynomial (uniform weights) the result is a single
-     * exact segment.
+     * 2D; if the symmetric Hausdorff distance between the rational segment and
+     * its candidate exceeds `tolerance` (verified via a certified subdivision
+     * bound, not a single-point sample), the segment is split at `t = 0.5` and
+     * the procedure recurses on each half. Returns a non-empty array; for a
+     * curve that is already polynomial (uniform weights) the result is a
+     * single exact segment.
+     *
+     * The Hausdorff guarantee means: every point on the rational lies within
+     * `tolerance` of some output segment, and every point on the output lies
+     * within `tolerance` of the rational — a true two-sided bound on geometric
+     * deviation, not just a parametric error at one sample.
      *
      * @param c - The rational cubic curve to approximate.
-     * @param tolerance - Maximum allowed midpoint deviation; must be positive.
+     * @param tolerance - Maximum allowed Hausdorff distance; must be positive.
      * @returns A sequence of polynomial cubic curves covering the input.
      * @since 2.0.0
      */
@@ -192,7 +233,7 @@ export declare const approximateAsCubicCurves: {
     /**
      * Approximates the rational cubic as a sequence of polynomial cubic curves.
      *
-     * @param tolerance - Maximum allowed midpoint deviation; must be positive.
+     * @param tolerance - Maximum allowed Hausdorff distance; must be positive.
      * @returns A function that takes a curve and returns its polynomial approximation.
      * @since 2.0.0
      */

package/dist/curve/rationalCubic2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const RationalCubicCurve2dTypeId: unique symbol;
+export type RationalCubicCurve2dTypeId = typeof RationalCubicCurve2dTypeId;

package/dist/interval/index.d.ts

@@ -1,6 +1,6 @@
-import * as IntervalNs from './interval';
-import * as Interval2dNs from './interval2d';
-export { IntervalNs as Interval };
+import * as IntervalNs from './interval.ts';
+import * as Interval2dNs from './interval2d.ts';
 export type Interval = IntervalNs.Interval;
+export { IntervalNs as Interval };
+export type Interval2d<X extends IntervalNs.Interval = IntervalNs.Interval, Y extends IntervalNs.Interval = IntervalNs.Interval> = Interval2dNs.Interval2d<X, Y>;
 export { Interval2dNs as Interval2d };
-export type Interval2d = Interval2dNs.Interval2d;

package/dist/interval/index.mjs

@@ -1,3 +1,3 @@
-import { s as interval_exports } from "../shared/interval-X1EYuf-T.mjs";
-import { t as interval2d_exports } from "../shared/interval2d-ca0J1NMr.mjs";
+import { s as interval_exports } from "../shared/interval-CqC3ZIqj.mjs";
+import { n as interval2d_exports } from "../shared/interval2d-BMDmeL1M.mjs";
 export { interval_exports as Interval, interval2d_exports as Interval2d };

package/dist/interval/interval.d.ts

@@ -1,4 +1,4 @@
-import type { Pipeable } from '../utils';
+import type { Pipeable } from '../utils.ts';
 /**
  * The structural minimum: any value with numeric `start` and `end` fields.
  *

package/dist/interval/interval.internal.d.ts

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

package/dist/interval/interval2d.d.ts

@@ -1,11 +1,7 @@
-import type { Pipeable } from '../utils';
-import type { Vector2 } from '../vector/vector2';
-import type { Bounds, Closed, Interval } from './interval';
-
-declare const Interval2dTypeId: unique symbol;
-type Interval2dTypeId = typeof Interval2dTypeId;
-
-
+import type { Pipeable } from '../utils.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { Bounds, Closed, Interval } from './interval.ts';
+import type { Interval2dTypeId } from './interval2d.internal.ts';
 /**
  * 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
@@ -165,3 +161,44 @@ export declare const equals: {
      */
     (b: Interval2d): (a: Interval2d) => boolean;
 };
+export declare const minDistance: {
+    /**
+     * Euclidean distance between the two closest points of two axis-aligned 2D
+     * intervals. Returns `0` when the boxes overlap (including edge or corner
+     * touching). Accepts the broader {@link Bounds2d} type — endpoint
+     * inclusivity is not consulted, so a "touching" pair of open intervals still
+     * returns `0` because the closest *points* coincide geometrically.
+     *
+     * @param a - The first 2D interval.
+     * @param b - The second 2D interval.
+     * @returns The minimum Euclidean distance between any point of `a` and any point of `b`.
+     * @since 2.0.0
+     */
+    (a: Bounds2d, b: Bounds2d): number;
+    /**
+     * @param b - The second 2D interval.
+     * @returns A function that takes the first 2D interval and returns the minimum distance.
+     * @since 2.0.0
+     */
+    (b: Bounds2d): (a: Bounds2d) => number;
+};
+export declare const maxDistance: {
+    /**
+     * Euclidean distance between the two farthest points of two axis-aligned 2D
+     * intervals. Equals the diagonal of the union AABB enclosing both inputs.
+     * Accepts the broader {@link Bounds2d} type — endpoint inclusivity is not
+     * consulted.
+     *
+     * @param a - The first 2D interval.
+     * @param b - The second 2D interval.
+     * @returns The maximum Euclidean distance between any point of `a` and any point of `b`.
+     * @since 2.0.0
+     */
+    (a: Bounds2d, b: Bounds2d): number;
+    /**
+     * @param b - The second 2D interval.
+     * @returns A function that takes the first 2D interval and returns the maximum distance.
+     * @since 2.0.0
+     */
+    (b: Bounds2d): (a: Bounds2d) => number;
+};

package/dist/interval/interval2d.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const Interval2dTypeId: unique symbol;
+export type Interval2dTypeId = typeof Interval2dTypeId;

package/dist/matrix/index.d.ts

@@ -1,9 +1,9 @@
-import * as Matrix2x2Ns from './matrix2x2';
-import * as Matrix3x3Ns from './matrix3x3';
-import * as Matrix4x4Ns from './matrix4x4';
-export { Matrix2x2Ns as Matrix2x2 };
+import * as Matrix2x2Ns from './matrix2x2.ts';
+import * as Matrix3x3Ns from './matrix3x3.ts';
+import * as Matrix4x4Ns from './matrix4x4.ts';
 export type Matrix2x2 = Matrix2x2Ns.Matrix2x2;
-export { Matrix3x3Ns as Matrix3x3 };
+export { Matrix2x2Ns as Matrix2x2 };
 export type Matrix3x3 = Matrix3x3Ns.Matrix3x3;
-export { Matrix4x4Ns as Matrix4x4 };
+export { Matrix3x3Ns as Matrix3x3 };
 export type Matrix4x4 = Matrix4x4Ns.Matrix4x4;
+export { Matrix4x4Ns as Matrix4x4 };

package/dist/matrix/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
-import { A as isMatrix2x2$1, B as transpose$2, C as vectorProductLeft$3, D as equals$2, E as determinant$2, F as setColumn$2, H as vectorProductRight$2, I as setRow$2, L as solveSystem$2, M as reverseColumns$2, N as reverseRows$2, O as fromColumns$2, P as rowVector$2, R as toColumns$2, S as transpose$3, T as columnVector$2, V as vectorProductLeft$2, _ as setColumn$3, b as toColumns$3, c as equals$3, d as isMatrix3x3$1, f as make$3, g as rowVector$3, h as reverseRows$3, j as make$2, k as fromRows$2, l as fromColumns$3, m as reverseColumns$3, o as columnVector$3, p as minor$1, r as matrix4x4_exports, s as determinant$3, u as fromRows$3, v as setRow$3, w as vectorProductRight$3, x as toRows$3, y as solveSystem$3, z as toRows$2 } from "../shared/matrix4x4-Ck2WROK-.mjs";
+import { A as isMatrix2x2$1, B as transpose$2, C as vectorProductLeft$3, D as equals$2, E as determinant$2, F as setColumn$2, H as vectorProductRight$2, I as setRow$2, L as solveSystem$2, M as reverseColumns$2, N as reverseRows$2, O as fromColumns$2, P as rowVector$2, R as toColumns$2, S as transpose$3, T as columnVector$2, V as vectorProductLeft$2, _ as setColumn$3, b as toColumns$3, c as equals$3, d as isMatrix3x3$1, f as make$3, g as rowVector$3, h as reverseRows$3, j as make$2, k as fromRows$2, l as fromColumns$3, m as reverseColumns$3, o as columnVector$3, p as minor$1, r as matrix4x4_exports, s as determinant$3, u as fromRows$3, v as setRow$3, w as vectorProductRight$3, x as toRows$3, y as solveSystem$3, z as toRows$2 } from "../shared/matrix4x4-qyRufxfs.mjs";
 //#region src/matrix/matrix2x2.ts
 var matrix2x2_exports = /* @__PURE__ */ __exportAll({
 	columnVector: () => columnVector$1,

package/dist/matrix/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["internal.isMatrix2x2","equals","internal.equals","make","internal.make","fromRows","internal.fromRows","fromColumns","internal.fromColumns","setRow","internal.setRow","setColumn","internal.setColumn","determinant","internal.determinant","vectorProductLeft","internal.vectorProductLeft","vectorProductRight","internal.vectorProductRight","solveSystem","internal.solveSystem","toRows","internal.toRows","toColumns","internal.toColumns","rowVector","internal.rowVector","columnVector","internal.columnVector","transpose","internal.transpose","reverseRows","internal.reverseRows","reverseColumns","internal.reverseColumns","internal.isMatrix3x3","internal.equals","internal.make","internal.fromRows","internal.fromColumns","internal.setRow","internal.setColumn","internal.determinant","internal.minor","internal.vectorProductLeft","internal.vectorProductRight","internal.solveSystem","internal.toRows","internal.toColumns","internal.rowVector","internal.columnVector","internal.transpose","internal.reverseRows","internal.reverseColumns"],"sources":["../../src/matrix/matrix2x2.ts","../../src/matrix/matrix3x3.ts"],"sourcesContent":["import type { TwoDimensionalComponent, TwoDimensionalIndex } from '../dimensions'\nimport type { Pipeable } from '../utils'\nimport type { Vector2 } from '../vector/vector2'\nimport type { Matrix2x2TypeId } from './matrix2x2.internal'\nimport * as internal from './matrix2x2.internal'\n\n/**\n * A type representing the coordinate of a 2D matrix.\n *\n * @since 1.0.0\n */\nexport type Matrix2x2Coordinate = TwoDimensionalIndex | TwoDimensionalComponent\n\n/**\n * A 2D matrix with 2 rows and 2 columns.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Matrix2x2 extends Pipeable {\n  readonly [Matrix2x2TypeId]: Matrix2x2TypeId\n\n  /**\n   * The value in the first row and first column.\n   */\n  readonly m00: number\n  /**\n   * The value in the first row and second column.\n   */\n  readonly m01: number\n  /**\n   * The value in the second row and first column.\n   */\n  readonly m10: number\n  /**\n   * The value in the second row and second column.\n   */\n  readonly m11: number\n}\n\n/**\n * Checks if a value is a `Matrix2x2`.\n *\n * @param m - The value to check.\n * @returns `true` if the value is a `Matrix2x2`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isMatrix2x2: (m: unknown) => m is Matrix2x2 = internal.isMatrix2x2\n\nexport const equals: {\n  /**\n   * Checks if two `Matrix2x2` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first matrix.\n   * @param b - The second matrix.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Matrix2x2, b: Matrix2x2): boolean\n  /**\n   * Checks if two `Matrix2x2` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second matrix.\n   * @returns A function that takes the first matrix and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Matrix2x2): (a: Matrix2x2) => boolean\n} = internal.equals\n\n/**\n * Creates a new `Matrix2x2` instance.\n *\n * @param m00 - The value in the first row and first column. Defaults to 0.\n * @param m01 - The value in the first row and second column. Defaults to 0.\n * @param m10 - The value in the second row and first column. Defaults to 0.\n * @param m11 - The value in the second row and second column. Defaults to 0.\n */\nexport const make: (m00?: number, m01?: number, m10?: number, m11?: number) => Matrix2x2 =\n  internal.make\n\n/**\n * Creates a new `Matrix2x2` instance from two vectors representing rows.\n *\n * @param v0 - The first row vector.\n * @param v1 - The second row vector.\n * @returns A new `Matrix2x2` instance.\n * @since 1.0.0\n */\nexport const fromRows: (v0: Vector2, v1: Vector2) => Matrix2x2 = internal.fromRows\n\n/**\n * Creates a new `Matrix2x2` instance from two vectors representing columns.\n *\n * @param v0 - The first column vector.\n * @param v1 - The second column vector.\n * @returns A new `Matrix2x2` instance.\n * @since 1.0.0\n */\nexport const fromColumns: (v0: Vector2, v1: Vector2) => Matrix2x2 = internal.fromColumns\n\nexport const setRow: {\n  /**\n   * Sets the specified row of the matrix to the given vector.\n   *\n   * @param m - The matrix to modify.\n   * @param row - The row index (0 or 1).\n   * @param v - The vector to set the row to.\n   * @returns A new `Matrix2x2` instance with the specified row set to the given vector.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, row: Matrix2x2Coordinate, v: Vector2): Matrix2x2\n  /**\n   * Sets the specified row of the matrix to the given vector.\n   *\n   * @param row - The row index (0 or 1).\n   * @param v - The vector to set the row to.\n   * @returns A function that takes a matrix and returns a new `Matrix2x2` instance with the specified row set to the given vector.\n   * @since 1.0.0\n   */\n  (row: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2\n} = internal.setRow\n\nexport const setColumn: {\n  /**\n   * Sets the specified column of the matrix to the given vector.\n   *\n   * @param m - The matrix to modify.\n   * @param column - The column index (0 or 1).\n   * @param v - The vector to set the column to.\n   * @returns A new `Matrix2x2` instance with the specified column set to the given vector.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, column: Matrix2x2Coordinate, v: Vector2): Matrix2x2\n  /**\n   * Sets the specified column of the matrix to the given vector.\n   *\n   * @param column - The column index (0 or 1).\n   * @param v - The vector to set the column to.\n   * @returns A function that takes a matrix and returns a new `Matrix2x2` instance with the specified column set to the given vector.\n   * @since 1.0.0\n   */\n  (column: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2\n} = internal.setColumn\n\n/**\n * Calculates the determinant of a 2D matrix.\n *\n * @param m - The matrix to calculate the determinant for.\n * @returns The determinant of the matrix.\n * @since 1.0.0\n */\nexport const determinant: (m: Matrix2x2) => number = internal.determinant\n\nexport const vectorProductLeft: {\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 2 * 6 = 17\n   * // y = 3 * 5 + 4 * 6 = 39\n   * const result = Matrix2x2.vectorProductLeft(matrix, vector)\n   * ```\n   * @param m - The matrix to multiply.\n   * @param v - The vector to multiply.\n   * @returns The resulting vector after the left vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, v: Vector2): Vector2\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 2 * 6 = 17\n   * // y = 3 * 5 + 4 * 6 = 39\n   * const result = Matrix2x2.vectorProductLeft(vector)(matrix)\n   * ```\n   * @param v - The vector to multiply.\n   * @returns A function that takes a matrix and returns the resulting vector after the left vector product.\n   * @since 1.0.0\n   */\n  (v: Vector2): (m: Matrix2x2) => Vector2\n} = internal.vectorProductLeft\n\nexport const vectorProductRight: {\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 3 * 6 = 33\n   * // y = 2 * 5 + 4 * 6 = 62\n   * const result = Matrix2x2.vectorProductRight(matrix, vector)\n   * ```\n   * @param m - The matrix to multiply.\n   * @param v - The vector to multiply.\n   * @returns The resulting vector after the right vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, v: Vector2): Vector2\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 3 * 6 = 33\n   * // y = 2 * 5 + 4 * 6 = 62\n   * const result = Matrix2x2.vectorProductRight(vector)(matrix)\n   * ```\n   * @param v - The vector to multiply.\n   * @returns A function that takes a matrix and returns the resulting vector after the right vector product.\n   * @since 1.0.0\n   */\n  (v: Vector2): (m: Matrix2x2) => Vector2\n} = internal.vectorProductRight\n\nexport const solveSystem: {\n  /**\n   * Solves a system of linear equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Solves the system of equations:\n   * // 1x + 2y = 5\n   * // 3x + 4y = 6\n   * const result = Matrix2x2.solveSystem(matrix, vector)\n   * ```\n   * @param m - The matrix representing the coefficients of the system.\n   * @param v - The vector representing the constants of the system.\n   * @returns The solution vector.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, v: Vector2): Vector2\n  /**\n   * Solves a system of linear equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Solves the system of equations:\n   * // 1x + 2y = 5\n   * // 3x + 4y = 6\n   * const result = Matrix2x2.solveSystem(vector)(matrix)\n   * ```\n   * @param v - The vector representing the constants of the system.\n   * @returns A function that takes a matrix and returns the solution vector.\n   * @since 1.0.0\n   */\n  (v: Vector2): (m: Matrix2x2) => Vector2\n} = internal.solveSystem\n\n/**\n * Returns the rows of a matrix as an array of vectors.\n *\n * @param m - The matrix to convert.\n * @returns An array of vectors representing the rows of the matrix.\n * @since 1.0.0\n */\nexport const toRows: (m: Matrix2x2) => [Vector2, Vector2] = internal.toRows\n\n/**\n * Returns the columns of a matrix as an array of vectors.\n *\n * @param m - The matrix to convert.\n * @returns An array of vectors representing the columns of the matrix.\n * @since 1.0.0\n */\nexport const toColumns: (m: Matrix2x2) => [Vector2, Vector2] = internal.toColumns\n\n/**\n * Returns the specified row of a matrix as a vector.\n *\n * @param m - The matrix to get the row from.\n * @param row - The row index (0 or 1).\n * @returns A vector representing the specified row of the matrix.\n * @since 1.0.0\n */\nexport const rowVector: (m: Matrix2x2, row: Matrix2x2Coordinate) => Vector2 = internal.rowVector\n\n/**\n * Returns the specified column of a matrix as a vector.\n *\n * @param m - The matrix to get the column from.\n * @param column - The column index (0 or 1).\n * @returns A vector representing the specified column of the matrix.\n * @since 1.0.0\n */\nexport const columnVector: (m: Matrix2x2, column: Matrix2x2Coordinate) => Vector2 =\n  internal.columnVector\n\n/**\n * Transposes a matrix.\n *\n * @param m - The matrix to transpose.\n * @returns A new `Matrix2x2` instance representing the transposed matrix.\n * @since 1.0.0\n */\nexport const transpose: (m: Matrix2x2) => Matrix2x2 = internal.transpose\n\n/**\n * Reverses the rows of a matrix.\n *\n * @param m - The matrix to reverse the rows of.\n * @returns A new `Matrix2x2` instance with the rows reversed.\n * @since 1.0.0\n */\nexport const reverseRows: (m: Matrix2x2) => Matrix2x2 = internal.reverseRows\n\n/**\n * Reverses the columns of a matrix.\n *\n * @param m - The matrix to reverse the columns of.\n * @returns A new `Matrix2x2` instance with the columns reversed.\n * @since 1.0.0\n */\nexport const reverseColumns: (m: Matrix2x2) => Matrix2x2 = internal.reverseColumns\n","import type { ThreeDimensionalComponent, ThreeDimensionalIndex } from '../dimensions'\nimport type { Pipeable } from '../utils'\nimport type { Vector3 } from '../vector/vector3'\nimport type { Matrix2x2 } from './matrix2x2'\nimport type { Matrix3x3TypeId } from './matrix3x3.internal'\nimport * as internal from './matrix3x3.internal'\n\n/**\n * A coordinate in a 3x3 matrix.\n *\n * @since 1.0.0\n */\nexport type Matrix3x3Coordinate = ThreeDimensionalIndex | ThreeDimensionalComponent\n\n/**\n * A 3x3 matrix.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Matrix3x3 extends Pipeable {\n  readonly [Matrix3x3TypeId]: Matrix3x3TypeId\n  /**\n   * The value of the first row and first column.\n   */\n  readonly m00: number\n  /**\n   * The value of the first row and second column.\n   */\n  readonly m01: number\n  /**\n   * The value of the first row and third column.\n   */\n  readonly m02: number\n  /**\n   * The value of the second row and first column.\n   */\n  readonly m10: number\n  /**\n   * The value of the second row and second column.\n   */\n  readonly m11: number\n  /**\n   * The value of the second row and third column.\n   */\n  readonly m12: number\n  /**\n   * The value of the third row and first column.\n   */\n  readonly m20: number\n  /**\n   * The value of the third row and second column.\n   */\n  readonly m21: number\n  /**\n   * The value of the third row and third column.\n   */\n  readonly m22: number\n}\n\n/**\n * Checks if a value is a `Matrix3x3`.\n *\n * @param m - The value to check.\n * @returns `true` if the value is a `Matrix3x3`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isMatrix3x3: (m: unknown) => m is Matrix3x3 = internal.isMatrix3x3\n\nexport const equals: {\n  /**\n   * Checks if two `Matrix3x3` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first matrix.\n   * @param b - The second matrix.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Matrix3x3, b: Matrix3x3): boolean\n  /**\n   * Checks if two `Matrix3x3` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second matrix.\n   * @returns A function that takes the first matrix and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Matrix3x3): (a: Matrix3x3) => boolean\n} = internal.equals\n\n/**\n * Creates a new `Matrix3x3` instance.\n *\n * @param m00 - The value of the first row and first column.\n * @param m01 - The value of the first row and second column.\n * @param m02 - The value of the first row and third column.\n * @param m10 - The value of the second row and first column.\n * @param m11 - The value of the second row and second column.\n * @param m12 - The value of the second row and third column.\n * @param m20 - The value of the third row and first column.\n * @param m21 - The value of the third row and second column.\n * @param m22 - The value of the third row and third column.\n * @returns A new `Matrix3x3` instance.\n * @since 1.0.0\n */\nexport const make: (\n  m00?: number,\n  m01?: number,\n  m02?: number,\n  m10?: number,\n  m11?: number,\n  m12?: number,\n  m20?: number,\n  m21?: number,\n  m22?: number,\n) => Matrix3x3 = internal.make\n\n/**\n * Creates a new `Matrix3x3` instance from three row vectors.\n *\n * @param v0 - The first row vector.\n * @param v1 - The second row vector.\n * @param v2 - The third row vector.\n * @returns A new `Matrix3x3` instance.\n * @since 1.0.0\n */\nexport const fromRows: (v0: Vector3, v1: Vector3, v2: Vector3) => Matrix3x3 = internal.fromRows\n\n/**\n * Creates a new `Matrix3x3` instance from three column vectors.\n *\n * @param v0 - The first column vector.\n * @param v1 - The second column vector.\n * @param v2 - The third column vector.\n * @returns A new `Matrix3x3` instance.\n * @since 1.0.0\n */\nexport const fromColumns: (v0: Vector3, v1: Vector3, v2: Vector3) => Matrix3x3 =\n  internal.fromColumns\n\nexport const setRow: {\n  /**\n   * Sets a row of the matrix to a new vector.\n   *\n   * @param m - The matrix to set the row of.\n   * @param row - The row index to set.\n   * @param v - The new vector for the row.\n   * @returns A new matrix with the specified row set to the new vector.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, row: Matrix3x3Coordinate, v: Vector3): Matrix3x3\n  /**\n   * Sets a row of the matrix to a new vector.\n   *\n   * @param row - The row index to set.\n   * @param v - The new vector for the row.\n   * @returns A function that takes a matrix and returns a new matrix with the specified row set to the new vector.\n   * @since 1.0.0\n   */\n  (row: Matrix3x3Coordinate, v: Vector3): (m: Matrix3x3) => Matrix3x3\n} = internal.setRow\n\nexport const setColumn: {\n  /**\n   * Sets a column of the matrix to a new vector.\n   *\n   * @param m - The matrix to set the column of.\n   * @param column - The column index to set.\n   * @param v - The new vector for the column.\n   * @returns A new matrix with the specified column set to the new vector.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, column: Matrix3x3Coordinate, v: Vector3): Matrix3x3\n  /**\n   * Sets a column of the matrix to a new vector.\n   *\n   * @param column - The column index to set.\n   * @param v - The new vector for the column.\n   * @returns A function that takes a matrix and returns a new matrix with the specified column set to the new vector.\n   * @since 1.0.0\n   */\n  (column: Matrix3x3Coordinate, v: Vector3): (m: Matrix3x3) => Matrix3x3\n} = internal.setColumn\n\n/**\n * Calculates the determinant of a 3x3 matrix.\n *\n * @param m - The matrix to calculate the determinant of.\n * @returns The determinant of the matrix.\n * @since 1.0.0\n */\nexport const determinant: (m: Matrix3x3) => number = internal.determinant\n\n/**\n * Calculates the minor of a 3x3 matrix.\n *\n * @param m - The matrix to calculate the minor of.\n * @param row - The row index of the element to calculate the minor for.\n * @param column - The column index of the element to calculate the minor for.\n * @returns The minor of the matrix at the specified row and column.\n * @since 1.0.0\n */\nexport const minor: (\n  m: Matrix3x3,\n  row: Matrix3x3Coordinate,\n  column: Matrix3x3Coordinate,\n) => Matrix2x2 = internal.minor\n\nexport const vectorProductLeft: {\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 2 * 11 + 3 * 12\n   * // y = 4 * 10 + 5 * 11 + 6 * 12\n   * // z = 7 * 10 + 8 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductLeft(m, v)\n   * ```\n   * @param m - The matrix to calculate the left vector product with.\n   * @param v - The vector to calculate the left vector product with.\n   * @returns The resulting vector from the left vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, v: Vector3): Vector3\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 2 * 11 + 3 * 12\n   * // y = 4 * 10 + 5 * 11 + 6 * 12\n   * // z = 7 * 10 + 8 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductLeft(v)(m)\n   * ```\n   * @param v - The vector to calculate the left vector product with.\n   * @returns A function that takes a matrix and returns the resulting vector from the left vector product.\n   * @since 1.0.0\n   */\n  (v: Vector3): (m: Matrix3x3) => Vector3\n} = internal.vectorProductLeft\n\nexport const vectorProductRight: {\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 4 * 11 + 7 * 12\n   * // y = 2 * 10 + 5 * 11 + 8 * 12\n   * // z = 3 * 10 + 6 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductRight(m, v)\n   * ```\n   * @param m - The matrix to calculate the right vector product with.\n   * @param v - The vector to calculate the right vector product with.\n   * @returns The resulting vector from the right vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, v: Vector3): Vector3\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 4 * 11 + 7 * 12\n   * // y = 2 * 10 + 5 * 11 + 8 * 12\n   * // z = 3 * 10 + 6 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductRight(v)(m)\n   * ```\n   * @param v - The vector to calculate the right vector product with.\n   * @returns A function that takes a matrix and returns the resulting vector from the right vector product.\n   * @since 1.0.0\n   */\n  (v: Vector3): (m: Matrix3x3) => Vector3\n} = internal.vectorProductRight\n\nexport const solveSystem: {\n  /**\n   * Solves a system of equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = m00 * x + m01 * y + m02 * z\n   * // y = m10 * x + m11 * y + m12 * z\n   * // z = m20 * x + m21 * y + m22 * z\n   * const result = Matrix3x3.solveSystem(m, v)\n   * ```\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, v: Vector3): Vector3\n  /**\n   * Solves a system of equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = m00 * x + m01 * y + m02 * z\n   * // y = m10 * x + m11 * y + m12 * z\n   * // z = m20 * x + m21 * y + m22 * z\n   * const result = Matrix3x3.solveSystem(v)(m)\n   * ```\n   * @since 1.0.0\n   */\n  (v: Vector3): (m: Matrix3x3) => Vector3\n} = internal.solveSystem\n\n/**\n * Returns the rows of a `Matrix3x3` as an array of vectors.\n *\n * @param m - The matrix to get the rows from.\n * @returns An array of vectors representing the rows of the matrix.\n * @since 1.0.0\n */\nexport const toRows: (m: Matrix3x3) => [Vector3, Vector3, Vector3] = internal.toRows as (\n  m: Matrix3x3,\n) => [Vector3, Vector3, Vector3]\n\n/**\n * Returns the columns of a `Matrix3x3` as an array of vectors.\n *\n * @param m - The matrix to get the columns from.\n * @returns An array of vectors representing the columns of the matrix.\n * @since 1.0.0\n */\nexport const toColumns: (m: Matrix3x3) => [Vector3, Vector3, Vector3] = internal.toColumns as (\n  m: Matrix3x3,\n) => [Vector3, Vector3, Vector3]\n\nexport const rowVector: {\n  /**\n   * Gets a row vector from the matrix.\n   *\n   * @param m - The matrix to get the row vector from.\n   * @param row - The row index to get the vector from.\n   * @returns The row vector at the specified index.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, row: Matrix3x3Coordinate): Vector3\n  /**\n   * Gets a row vector from the matrix.\n   *\n   * @param row - The row index to get the vector from.\n   * @returns A function that takes a matrix and returns the row vector at the specified index.\n   * @since 1.0.0\n   */\n  (row: Matrix3x3Coordinate): (m: Matrix3x3) => Vector3\n} = internal.rowVector\n\nexport const columnVector: {\n  /**\n   * Gets a column vector from the matrix.\n   *\n   * @param m - The matrix to get the column vector from.\n   * @param column - The column index to get the vector from.\n   * @returns The column vector at the specified index.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, column: Matrix3x3Coordinate): Vector3\n  /**\n   * Gets a column vector from the matrix.\n   *\n   * @param column - The column index to get the vector from.\n   * @returns A function that takes a matrix and returns the column vector at the specified index.\n   * @since 1.0.0\n   */\n  (column: Matrix3x3Coordinate): (m: Matrix3x3) => Vector3\n} = internal.columnVector\n\n/**\n * Transposes a `Matrix3x3`.\n *\n * @param m - The matrix to transpose.\n * @returns A new `Matrix3x3` instance that is the transpose of the input matrix.\n * @since 1.0.0\n */\nexport const transpose: (m: Matrix3x3) => Matrix3x3 = internal.transpose\n\n/**\n * Reverses the rows of a `Matrix3x3`.\n *\n * @param m - The matrix to reverse the rows of.\n * @returns A new `Matrix3x3` instance with the rows reversed.\n * @since 1.0.0\n */\nexport const reverseRows: (m: Matrix3x3) => Matrix3x3 = internal.reverseRows\n\n/**\n * Reverses the columns of a `Matrix3x3`.\n *\n * @param m - The matrix to reverse the columns of.\n * @returns A new `Matrix3x3` instance with the columns reversed.\n * @since 1.0.0\n */\nexport const reverseColumns: (m: Matrix3x3) => Matrix3x3 = internal.reverseColumns\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,cAA8CA;AAE3D,MAAaC,WAoBTC;;;;;;;;;AAUJ,MAAaC,SACXC;;;;;;;;;AAUF,MAAaC,aAAoDC;;;;;;;;;AAUjE,MAAaC,gBAAuDC;AAEpE,MAAaC,WAoBTC;AAEJ,MAAaC,cAoBTC;;;;;;;;AASJ,MAAaC,gBAAwCC;AAErD,MAAaC,sBA4CTC;AAEJ,MAAaC,uBA4CTC;AAEJ,MAAaC,gBA4CTC;;;;;;;;AASJ,MAAaC,WAA+CC;;;;;;;;AAS5D,MAAaC,cAAkDC;;;;;;;;;AAU/D,MAAaC,cAAiEC;;;;;;;;;AAU9E,MAAaC,iBACXC;;;;;;;;AASF,MAAaC,cAAyCC;;;;;;;;AAStD,MAAaC,gBAA2CC;;;;;;;;AASxD,MAAaC,mBAA8CC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClS3D,MAAa,cAA8CC;AAE3D,MAAa,SAoBTC;;;;;;;;;;;;;;;;AAiBJ,MAAa,OAUIC;;;;;;;;;;AAWjB,MAAa,WAAiEC;;;;;;;;;;AAW9E,MAAa,cACXC;AAEF,MAAa,SAoBTC;AAEJ,MAAa,YAoBTC;;;;;;;;AASJ,MAAa,cAAwCC;;;;;;;;;;AAWrD,MAAa,QAIIC;AAEjB,MAAa,oBA8CTC;AAEJ,MAAa,qBA8CTC;AAEJ,MAAa,cAyCTC;;;;;;;;AASJ,MAAa,SAAwDC;;;;;;;;AAWrE,MAAa,YAA2DC;AAIxE,MAAa,YAkBTC;AAEJ,MAAa,eAkBTC;;;;;;;;AASJ,MAAa,YAAyCC;;;;;;;;AAStD,MAAa,cAA2CC;;;;;;;;AASxD,MAAa,iBAA8CC"}
+{"version":3,"file":"index.mjs","names":["internal.isMatrix2x2","equals","internal.equals","make","internal.make","fromRows","internal.fromRows","fromColumns","internal.fromColumns","setRow","internal.setRow","setColumn","internal.setColumn","determinant","internal.determinant","vectorProductLeft","internal.vectorProductLeft","vectorProductRight","internal.vectorProductRight","solveSystem","internal.solveSystem","toRows","internal.toRows","toColumns","internal.toColumns","rowVector","internal.rowVector","columnVector","internal.columnVector","transpose","internal.transpose","reverseRows","internal.reverseRows","reverseColumns","internal.reverseColumns","internal.isMatrix3x3","internal.equals","internal.make","internal.fromRows","internal.fromColumns","internal.setRow","internal.setColumn","internal.determinant","internal.minor","internal.vectorProductLeft","internal.vectorProductRight","internal.solveSystem","internal.toRows","internal.toColumns","internal.rowVector","internal.columnVector","internal.transpose","internal.reverseRows","internal.reverseColumns"],"sources":["../../src/matrix/matrix2x2.ts","../../src/matrix/matrix3x3.ts"],"sourcesContent":["import type { TwoDimensionalComponent, TwoDimensionalIndex } from '../dimensions.ts'\nimport type { Pipeable } from '../utils.ts'\nimport type { Vector2 } from '../vector/vector2.ts'\nimport type { Matrix2x2TypeId } from './matrix2x2.internal.ts'\nimport * as internal from './matrix2x2.internal.ts'\n\n/**\n * A type representing the coordinate of a 2D matrix.\n *\n * @since 1.0.0\n */\nexport type Matrix2x2Coordinate = TwoDimensionalIndex | TwoDimensionalComponent\n\n/**\n * A 2D matrix with 2 rows and 2 columns.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Matrix2x2 extends Pipeable {\n  readonly [Matrix2x2TypeId]: Matrix2x2TypeId\n\n  /**\n   * The value in the first row and first column.\n   */\n  readonly m00: number\n  /**\n   * The value in the first row and second column.\n   */\n  readonly m01: number\n  /**\n   * The value in the second row and first column.\n   */\n  readonly m10: number\n  /**\n   * The value in the second row and second column.\n   */\n  readonly m11: number\n}\n\n/**\n * Checks if a value is a `Matrix2x2`.\n *\n * @param m - The value to check.\n * @returns `true` if the value is a `Matrix2x2`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isMatrix2x2: (m: unknown) => m is Matrix2x2 = internal.isMatrix2x2\n\nexport const equals: {\n  /**\n   * Checks if two `Matrix2x2` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first matrix.\n   * @param b - The second matrix.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Matrix2x2, b: Matrix2x2): boolean\n  /**\n   * Checks if two `Matrix2x2` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second matrix.\n   * @returns A function that takes the first matrix and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Matrix2x2): (a: Matrix2x2) => boolean\n} = internal.equals\n\n/**\n * Creates a new `Matrix2x2` instance.\n *\n * @param m00 - The value in the first row and first column. Defaults to 0.\n * @param m01 - The value in the first row and second column. Defaults to 0.\n * @param m10 - The value in the second row and first column. Defaults to 0.\n * @param m11 - The value in the second row and second column. Defaults to 0.\n */\nexport const make: (m00?: number, m01?: number, m10?: number, m11?: number) => Matrix2x2 =\n  internal.make\n\n/**\n * Creates a new `Matrix2x2` instance from two vectors representing rows.\n *\n * @param v0 - The first row vector.\n * @param v1 - The second row vector.\n * @returns A new `Matrix2x2` instance.\n * @since 1.0.0\n */\nexport const fromRows: (v0: Vector2, v1: Vector2) => Matrix2x2 = internal.fromRows\n\n/**\n * Creates a new `Matrix2x2` instance from two vectors representing columns.\n *\n * @param v0 - The first column vector.\n * @param v1 - The second column vector.\n * @returns A new `Matrix2x2` instance.\n * @since 1.0.0\n */\nexport const fromColumns: (v0: Vector2, v1: Vector2) => Matrix2x2 = internal.fromColumns\n\nexport const setRow: {\n  /**\n   * Sets the specified row of the matrix to the given vector.\n   *\n   * @param m - The matrix to modify.\n   * @param row - The row index (0 or 1).\n   * @param v - The vector to set the row to.\n   * @returns A new `Matrix2x2` instance with the specified row set to the given vector.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, row: Matrix2x2Coordinate, v: Vector2): Matrix2x2\n  /**\n   * Sets the specified row of the matrix to the given vector.\n   *\n   * @param row - The row index (0 or 1).\n   * @param v - The vector to set the row to.\n   * @returns A function that takes a matrix and returns a new `Matrix2x2` instance with the specified row set to the given vector.\n   * @since 1.0.0\n   */\n  (row: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2\n} = internal.setRow\n\nexport const setColumn: {\n  /**\n   * Sets the specified column of the matrix to the given vector.\n   *\n   * @param m - The matrix to modify.\n   * @param column - The column index (0 or 1).\n   * @param v - The vector to set the column to.\n   * @returns A new `Matrix2x2` instance with the specified column set to the given vector.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, column: Matrix2x2Coordinate, v: Vector2): Matrix2x2\n  /**\n   * Sets the specified column of the matrix to the given vector.\n   *\n   * @param column - The column index (0 or 1).\n   * @param v - The vector to set the column to.\n   * @returns A function that takes a matrix and returns a new `Matrix2x2` instance with the specified column set to the given vector.\n   * @since 1.0.0\n   */\n  (column: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2\n} = internal.setColumn\n\n/**\n * Calculates the determinant of a 2D matrix.\n *\n * @param m - The matrix to calculate the determinant for.\n * @returns The determinant of the matrix.\n * @since 1.0.0\n */\nexport const determinant: (m: Matrix2x2) => number = internal.determinant\n\nexport const vectorProductLeft: {\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 2 * 6 = 17\n   * // y = 3 * 5 + 4 * 6 = 39\n   * const result = Matrix2x2.vectorProductLeft(matrix, vector)\n   * ```\n   * @param m - The matrix to multiply.\n   * @param v - The vector to multiply.\n   * @returns The resulting vector after the left vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, v: Vector2): Vector2\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 2 * 6 = 17\n   * // y = 3 * 5 + 4 * 6 = 39\n   * const result = Matrix2x2.vectorProductLeft(vector)(matrix)\n   * ```\n   * @param v - The vector to multiply.\n   * @returns A function that takes a matrix and returns the resulting vector after the left vector product.\n   * @since 1.0.0\n   */\n  (v: Vector2): (m: Matrix2x2) => Vector2\n} = internal.vectorProductLeft\n\nexport const vectorProductRight: {\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 3 * 6 = 33\n   * // y = 2 * 5 + 4 * 6 = 62\n   * const result = Matrix2x2.vectorProductRight(matrix, vector)\n   * ```\n   * @param m - The matrix to multiply.\n   * @param v - The vector to multiply.\n   * @returns The resulting vector after the right vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, v: Vector2): Vector2\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Performs:\n   * // x = 1 * 5 + 3 * 6 = 33\n   * // y = 2 * 5 + 4 * 6 = 62\n   * const result = Matrix2x2.vectorProductRight(vector)(matrix)\n   * ```\n   * @param v - The vector to multiply.\n   * @returns A function that takes a matrix and returns the resulting vector after the right vector product.\n   * @since 1.0.0\n   */\n  (v: Vector2): (m: Matrix2x2) => Vector2\n} = internal.vectorProductRight\n\nexport const solveSystem: {\n  /**\n   * Solves a system of linear equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Solves the system of equations:\n   * // 1x + 2y = 5\n   * // 3x + 4y = 6\n   * const result = Matrix2x2.solveSystem(matrix, vector)\n   * ```\n   * @param m - The matrix representing the coefficients of the system.\n   * @param v - The vector representing the constants of the system.\n   * @returns The solution vector.\n   * @since 1.0.0\n   */\n  (m: Matrix2x2, v: Vector2): Vector2\n  /**\n   * Solves a system of linear equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix2x2 from 'curvy/matrix2x2'\n   * import * as Vector2 from 'curvy/vector2'\n   *\n   * const matrix = Matrix2x2.make(1, 2, 3, 4)\n   * const vector = Vector2.make(5, 6)\n   *\n   * // Solves the system of equations:\n   * // 1x + 2y = 5\n   * // 3x + 4y = 6\n   * const result = Matrix2x2.solveSystem(vector)(matrix)\n   * ```\n   * @param v - The vector representing the constants of the system.\n   * @returns A function that takes a matrix and returns the solution vector.\n   * @since 1.0.0\n   */\n  (v: Vector2): (m: Matrix2x2) => Vector2\n} = internal.solveSystem\n\n/**\n * Returns the rows of a matrix as an array of vectors.\n *\n * @param m - The matrix to convert.\n * @returns An array of vectors representing the rows of the matrix.\n * @since 1.0.0\n */\nexport const toRows: (m: Matrix2x2) => [Vector2, Vector2] = internal.toRows\n\n/**\n * Returns the columns of a matrix as an array of vectors.\n *\n * @param m - The matrix to convert.\n * @returns An array of vectors representing the columns of the matrix.\n * @since 1.0.0\n */\nexport const toColumns: (m: Matrix2x2) => [Vector2, Vector2] = internal.toColumns\n\n/**\n * Returns the specified row of a matrix as a vector.\n *\n * @param m - The matrix to get the row from.\n * @param row - The row index (0 or 1).\n * @returns A vector representing the specified row of the matrix.\n * @since 1.0.0\n */\nexport const rowVector: (m: Matrix2x2, row: Matrix2x2Coordinate) => Vector2 = internal.rowVector\n\n/**\n * Returns the specified column of a matrix as a vector.\n *\n * @param m - The matrix to get the column from.\n * @param column - The column index (0 or 1).\n * @returns A vector representing the specified column of the matrix.\n * @since 1.0.0\n */\nexport const columnVector: (m: Matrix2x2, column: Matrix2x2Coordinate) => Vector2 =\n  internal.columnVector\n\n/**\n * Transposes a matrix.\n *\n * @param m - The matrix to transpose.\n * @returns A new `Matrix2x2` instance representing the transposed matrix.\n * @since 1.0.0\n */\nexport const transpose: (m: Matrix2x2) => Matrix2x2 = internal.transpose\n\n/**\n * Reverses the rows of a matrix.\n *\n * @param m - The matrix to reverse the rows of.\n * @returns A new `Matrix2x2` instance with the rows reversed.\n * @since 1.0.0\n */\nexport const reverseRows: (m: Matrix2x2) => Matrix2x2 = internal.reverseRows\n\n/**\n * Reverses the columns of a matrix.\n *\n * @param m - The matrix to reverse the columns of.\n * @returns A new `Matrix2x2` instance with the columns reversed.\n * @since 1.0.0\n */\nexport const reverseColumns: (m: Matrix2x2) => Matrix2x2 = internal.reverseColumns\n","import type { ThreeDimensionalComponent, ThreeDimensionalIndex } from '../dimensions.ts'\nimport type { Pipeable } from '../utils.ts'\nimport type { Vector3 } from '../vector/vector3.ts'\nimport type { Matrix2x2 } from './matrix2x2.ts'\nimport type { Matrix3x3TypeId } from './matrix3x3.internal.ts'\nimport * as internal from './matrix3x3.internal.ts'\n\n/**\n * A coordinate in a 3x3 matrix.\n *\n * @since 1.0.0\n */\nexport type Matrix3x3Coordinate = ThreeDimensionalIndex | ThreeDimensionalComponent\n\n/**\n * A 3x3 matrix.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Matrix3x3 extends Pipeable {\n  readonly [Matrix3x3TypeId]: Matrix3x3TypeId\n  /**\n   * The value of the first row and first column.\n   */\n  readonly m00: number\n  /**\n   * The value of the first row and second column.\n   */\n  readonly m01: number\n  /**\n   * The value of the first row and third column.\n   */\n  readonly m02: number\n  /**\n   * The value of the second row and first column.\n   */\n  readonly m10: number\n  /**\n   * The value of the second row and second column.\n   */\n  readonly m11: number\n  /**\n   * The value of the second row and third column.\n   */\n  readonly m12: number\n  /**\n   * The value of the third row and first column.\n   */\n  readonly m20: number\n  /**\n   * The value of the third row and second column.\n   */\n  readonly m21: number\n  /**\n   * The value of the third row and third column.\n   */\n  readonly m22: number\n}\n\n/**\n * Checks if a value is a `Matrix3x3`.\n *\n * @param m - The value to check.\n * @returns `true` if the value is a `Matrix3x3`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isMatrix3x3: (m: unknown) => m is Matrix3x3 = internal.isMatrix3x3\n\nexport const equals: {\n  /**\n   * Checks if two `Matrix3x3` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first matrix.\n   * @param b - The second matrix.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Matrix3x3, b: Matrix3x3): boolean\n  /**\n   * Checks if two `Matrix3x3` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second matrix.\n   * @returns A function that takes the first matrix and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Matrix3x3): (a: Matrix3x3) => boolean\n} = internal.equals\n\n/**\n * Creates a new `Matrix3x3` instance.\n *\n * @param m00 - The value of the first row and first column.\n * @param m01 - The value of the first row and second column.\n * @param m02 - The value of the first row and third column.\n * @param m10 - The value of the second row and first column.\n * @param m11 - The value of the second row and second column.\n * @param m12 - The value of the second row and third column.\n * @param m20 - The value of the third row and first column.\n * @param m21 - The value of the third row and second column.\n * @param m22 - The value of the third row and third column.\n * @returns A new `Matrix3x3` instance.\n * @since 1.0.0\n */\nexport const make: (\n  m00?: number,\n  m01?: number,\n  m02?: number,\n  m10?: number,\n  m11?: number,\n  m12?: number,\n  m20?: number,\n  m21?: number,\n  m22?: number,\n) => Matrix3x3 = internal.make\n\n/**\n * Creates a new `Matrix3x3` instance from three row vectors.\n *\n * @param v0 - The first row vector.\n * @param v1 - The second row vector.\n * @param v2 - The third row vector.\n * @returns A new `Matrix3x3` instance.\n * @since 1.0.0\n */\nexport const fromRows: (v0: Vector3, v1: Vector3, v2: Vector3) => Matrix3x3 = internal.fromRows\n\n/**\n * Creates a new `Matrix3x3` instance from three column vectors.\n *\n * @param v0 - The first column vector.\n * @param v1 - The second column vector.\n * @param v2 - The third column vector.\n * @returns A new `Matrix3x3` instance.\n * @since 1.0.0\n */\nexport const fromColumns: (v0: Vector3, v1: Vector3, v2: Vector3) => Matrix3x3 =\n  internal.fromColumns\n\nexport const setRow: {\n  /**\n   * Sets a row of the matrix to a new vector.\n   *\n   * @param m - The matrix to set the row of.\n   * @param row - The row index to set.\n   * @param v - The new vector for the row.\n   * @returns A new matrix with the specified row set to the new vector.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, row: Matrix3x3Coordinate, v: Vector3): Matrix3x3\n  /**\n   * Sets a row of the matrix to a new vector.\n   *\n   * @param row - The row index to set.\n   * @param v - The new vector for the row.\n   * @returns A function that takes a matrix and returns a new matrix with the specified row set to the new vector.\n   * @since 1.0.0\n   */\n  (row: Matrix3x3Coordinate, v: Vector3): (m: Matrix3x3) => Matrix3x3\n} = internal.setRow\n\nexport const setColumn: {\n  /**\n   * Sets a column of the matrix to a new vector.\n   *\n   * @param m - The matrix to set the column of.\n   * @param column - The column index to set.\n   * @param v - The new vector for the column.\n   * @returns A new matrix with the specified column set to the new vector.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, column: Matrix3x3Coordinate, v: Vector3): Matrix3x3\n  /**\n   * Sets a column of the matrix to a new vector.\n   *\n   * @param column - The column index to set.\n   * @param v - The new vector for the column.\n   * @returns A function that takes a matrix and returns a new matrix with the specified column set to the new vector.\n   * @since 1.0.0\n   */\n  (column: Matrix3x3Coordinate, v: Vector3): (m: Matrix3x3) => Matrix3x3\n} = internal.setColumn\n\n/**\n * Calculates the determinant of a 3x3 matrix.\n *\n * @param m - The matrix to calculate the determinant of.\n * @returns The determinant of the matrix.\n * @since 1.0.0\n */\nexport const determinant: (m: Matrix3x3) => number = internal.determinant\n\n/**\n * Calculates the minor of a 3x3 matrix.\n *\n * @param m - The matrix to calculate the minor of.\n * @param row - The row index of the element to calculate the minor for.\n * @param column - The column index of the element to calculate the minor for.\n * @returns The minor of the matrix at the specified row and column.\n * @since 1.0.0\n */\nexport const minor: (\n  m: Matrix3x3,\n  row: Matrix3x3Coordinate,\n  column: Matrix3x3Coordinate,\n) => Matrix2x2 = internal.minor\n\nexport const vectorProductLeft: {\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 2 * 11 + 3 * 12\n   * // y = 4 * 10 + 5 * 11 + 6 * 12\n   * // z = 7 * 10 + 8 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductLeft(m, v)\n   * ```\n   * @param m - The matrix to calculate the left vector product with.\n   * @param v - The vector to calculate the left vector product with.\n   * @returns The resulting vector from the left vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, v: Vector3): Vector3\n  /**\n   * Calculates the left vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 2 * 11 + 3 * 12\n   * // y = 4 * 10 + 5 * 11 + 6 * 12\n   * // z = 7 * 10 + 8 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductLeft(v)(m)\n   * ```\n   * @param v - The vector to calculate the left vector product with.\n   * @returns A function that takes a matrix and returns the resulting vector from the left vector product.\n   * @since 1.0.0\n   */\n  (v: Vector3): (m: Matrix3x3) => Vector3\n} = internal.vectorProductLeft\n\nexport const vectorProductRight: {\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 4 * 11 + 7 * 12\n   * // y = 2 * 10 + 5 * 11 + 8 * 12\n   * // z = 3 * 10 + 6 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductRight(m, v)\n   * ```\n   * @param m - The matrix to calculate the right vector product with.\n   * @param v - The vector to calculate the right vector product with.\n   * @returns The resulting vector from the right vector product.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, v: Vector3): Vector3\n  /**\n   * Calculates the right vector product of a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = 1 * 10 + 4 * 11 + 7 * 12\n   * // y = 2 * 10 + 5 * 11 + 8 * 12\n   * // z = 3 * 10 + 6 * 11 + 9 * 12\n   * const result = Matrix3x3.vectorProductRight(v)(m)\n   * ```\n   * @param v - The vector to calculate the right vector product with.\n   * @returns A function that takes a matrix and returns the resulting vector from the right vector product.\n   * @since 1.0.0\n   */\n  (v: Vector3): (m: Matrix3x3) => Vector3\n} = internal.vectorProductRight\n\nexport const solveSystem: {\n  /**\n   * Solves a system of equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = m00 * x + m01 * y + m02 * z\n   * // y = m10 * x + m11 * y + m12 * z\n   * // z = m20 * x + m21 * y + m22 * z\n   * const result = Matrix3x3.solveSystem(m, v)\n   * ```\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, v: Vector3): Vector3\n  /**\n   * Solves a system of equations represented by a matrix and a vector.\n   *\n   * @example\n   * ```ts\n   * import * as Matrix3x3 from 'curvy/matrix3x3'\n   * import * as Vector3 from 'curvy/vector3'\n   *\n   * const m = Matrix3x3.make(1, 2, 3, 4, 5, 6, 7, 8, 9)\n   * const v = Vector3.vector3(10, 11, 12)\n   *\n   * // Performs:\n   * // x = m00 * x + m01 * y + m02 * z\n   * // y = m10 * x + m11 * y + m12 * z\n   * // z = m20 * x + m21 * y + m22 * z\n   * const result = Matrix3x3.solveSystem(v)(m)\n   * ```\n   * @since 1.0.0\n   */\n  (v: Vector3): (m: Matrix3x3) => Vector3\n} = internal.solveSystem\n\n/**\n * Returns the rows of a `Matrix3x3` as an array of vectors.\n *\n * @param m - The matrix to get the rows from.\n * @returns An array of vectors representing the rows of the matrix.\n * @since 1.0.0\n */\nexport const toRows: (m: Matrix3x3) => [Vector3, Vector3, Vector3] = internal.toRows as (\n  m: Matrix3x3,\n) => [Vector3, Vector3, Vector3]\n\n/**\n * Returns the columns of a `Matrix3x3` as an array of vectors.\n *\n * @param m - The matrix to get the columns from.\n * @returns An array of vectors representing the columns of the matrix.\n * @since 1.0.0\n */\nexport const toColumns: (m: Matrix3x3) => [Vector3, Vector3, Vector3] = internal.toColumns as (\n  m: Matrix3x3,\n) => [Vector3, Vector3, Vector3]\n\nexport const rowVector: {\n  /**\n   * Gets a row vector from the matrix.\n   *\n   * @param m - The matrix to get the row vector from.\n   * @param row - The row index to get the vector from.\n   * @returns The row vector at the specified index.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, row: Matrix3x3Coordinate): Vector3\n  /**\n   * Gets a row vector from the matrix.\n   *\n   * @param row - The row index to get the vector from.\n   * @returns A function that takes a matrix and returns the row vector at the specified index.\n   * @since 1.0.0\n   */\n  (row: Matrix3x3Coordinate): (m: Matrix3x3) => Vector3\n} = internal.rowVector\n\nexport const columnVector: {\n  /**\n   * Gets a column vector from the matrix.\n   *\n   * @param m - The matrix to get the column vector from.\n   * @param column - The column index to get the vector from.\n   * @returns The column vector at the specified index.\n   * @since 1.0.0\n   */\n  (m: Matrix3x3, column: Matrix3x3Coordinate): Vector3\n  /**\n   * Gets a column vector from the matrix.\n   *\n   * @param column - The column index to get the vector from.\n   * @returns A function that takes a matrix and returns the column vector at the specified index.\n   * @since 1.0.0\n   */\n  (column: Matrix3x3Coordinate): (m: Matrix3x3) => Vector3\n} = internal.columnVector\n\n/**\n * Transposes a `Matrix3x3`.\n *\n * @param m - The matrix to transpose.\n * @returns A new `Matrix3x3` instance that is the transpose of the input matrix.\n * @since 1.0.0\n */\nexport const transpose: (m: Matrix3x3) => Matrix3x3 = internal.transpose\n\n/**\n * Reverses the rows of a `Matrix3x3`.\n *\n * @param m - The matrix to reverse the rows of.\n * @returns A new `Matrix3x3` instance with the rows reversed.\n * @since 1.0.0\n */\nexport const reverseRows: (m: Matrix3x3) => Matrix3x3 = internal.reverseRows\n\n/**\n * Reverses the columns of a `Matrix3x3`.\n *\n * @param m - The matrix to reverse the columns of.\n * @returns A new `Matrix3x3` instance with the columns reversed.\n * @since 1.0.0\n */\nexport const reverseColumns: (m: Matrix3x3) => Matrix3x3 = internal.reverseColumns\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAa,cAA8CA;AAE3D,MAAaC,WAoBTC;;;;;;;;;AAUJ,MAAaC,SACXC;;;;;;;;;AAUF,MAAaC,aAAoDC;;;;;;;;;AAUjE,MAAaC,gBAAuDC;AAEpE,MAAaC,WAoBTC;AAEJ,MAAaC,cAoBTC;;;;;;;;AASJ,MAAaC,gBAAwCC;AAErD,MAAaC,sBA4CTC;AAEJ,MAAaC,uBA4CTC;AAEJ,MAAaC,gBA4CTC;;;;;;;;AASJ,MAAaC,WAA+CC;;;;;;;;AAS5D,MAAaC,cAAkDC;;;;;;;;;AAU/D,MAAaC,cAAiEC;;;;;;;;;AAU9E,MAAaC,iBACXC;;;;;;;;AASF,MAAaC,cAAyCC;;;;;;;;AAStD,MAAaC,gBAA2CC;;;;;;;;AASxD,MAAaC,mBAA8CC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClS3D,MAAa,cAA8CC;AAE3D,MAAa,SAoBTC;;;;;;;;;;;;;;;;AAiBJ,MAAa,OAUIC;;;;;;;;;;AAWjB,MAAa,WAAiEC;;;;;;;;;;AAW9E,MAAa,cACXC;AAEF,MAAa,SAoBTC;AAEJ,MAAa,YAoBTC;;;;;;;;AASJ,MAAa,cAAwCC;;;;;;;;;;AAWrD,MAAa,QAIIC;AAEjB,MAAa,oBA8CTC;AAEJ,MAAa,qBA8CTC;AAEJ,MAAa,cAyCTC;;;;;;;;AASJ,MAAa,SAAwDC;;;;;;;;AAWrE,MAAa,YAA2DC;AAIxE,MAAa,YAkBTC;AAEJ,MAAa,eAkBTC;;;;;;;;AASJ,MAAa,YAAyCC;;;;;;;;AAStD,MAAa,cAA2CC;;;;;;;;AASxD,MAAa,iBAA8CC"}

package/dist/matrix/matrix2x2.d.ts

@@ -1,11 +1,7 @@
-import type { TwoDimensionalComponent, TwoDimensionalIndex } from '../dimensions';
-import type { Pipeable } from '../utils';
-import type { Vector2 } from '../vector/vector2';
-
-declare const Matrix2x2TypeId: unique symbol;
-type Matrix2x2TypeId = typeof Matrix2x2TypeId;
-
-
+import type { TwoDimensionalComponent, TwoDimensionalIndex } from '../dimensions.ts';
+import type { Pipeable } from '../utils.ts';
+import type { Vector2 } from '../vector/vector2.ts';
+import type { Matrix2x2TypeId } from './matrix2x2.internal.ts';
 /**
  * A type representing the coordinate of a 2D matrix.
  *

package/dist/matrix/matrix2x2.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const Matrix2x2TypeId: unique symbol;
+export type Matrix2x2TypeId = typeof Matrix2x2TypeId;

package/dist/matrix/matrix3x3.d.ts

@@ -1,12 +1,8 @@
-import type { ThreeDimensionalComponent, ThreeDimensionalIndex } from '../dimensions';
-import type { Pipeable } from '../utils';
-import type { Vector3 } from '../vector/vector3';
-import type { Matrix2x2 } from './matrix2x2';
-
-declare const Matrix3x3TypeId: unique symbol;
-type Matrix3x3TypeId = typeof Matrix3x3TypeId;
-
-
+import type { ThreeDimensionalComponent, ThreeDimensionalIndex } from '../dimensions.ts';
+import type { Pipeable } from '../utils.ts';
+import type { Vector3 } from '../vector/vector3.ts';
+import type { Matrix2x2 } from './matrix2x2.ts';
+import type { Matrix3x3TypeId } from './matrix3x3.internal.ts';
 /**
  * A coordinate in a 3x3 matrix.
  *

package/dist/matrix/matrix3x3.internal.d.ts

@@ -0,0 +1,4 @@
+import type { Matrix3x3 } from './matrix3x3.ts';
+export declare const Matrix3x3TypeId: unique symbol;
+export type Matrix3x3TypeId = typeof Matrix3x3TypeId;
+export type { Matrix3x3 };

package/dist/matrix/matrix4x4.d.ts

@@ -1,12 +1,8 @@
-import type { FourDimensionalComponent, FourDimensionalIndex } from '../dimensions';
-import type { Pipeable } from '../utils';
-import type { Vector4 } from '../vector/vector4';
-import type { Matrix3x3 } from './matrix3x3';
-
-declare const Matrix4x4TypeId: unique symbol;
-type Matrix4x4TypeId = typeof Matrix4x4TypeId;
-
-
+import type { FourDimensionalComponent, FourDimensionalIndex } from '../dimensions.ts';
+import type { Pipeable } from '../utils.ts';
+import type { Vector4 } from '../vector/vector4.ts';
+import type { Matrix3x3 } from './matrix3x3.ts';
+import type { Matrix4x4TypeId } from './matrix4x4.internal.ts';
 /**
  * A coordinate in a 4x4 matrix.
  *

package/dist/matrix/matrix4x4.internal.d.ts

@@ -0,0 +1,2 @@
+export declare const Matrix4x4TypeId: unique symbol;
+export type Matrix4x4TypeId = typeof Matrix4x4TypeId;