curvy 1.0.8 → 1.0.9

package/dist/interval.d.ts

@@ -1,58 +1,251 @@
 import { Pipeable } from './pipe.js';
 
+/**
+ * A mathematical interval.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface Interval extends Pipeable {
     readonly start: number;
     readonly end: number;
 }
+/**
+ * Checks if a value is an `Interval`.
+ *
+ * @param v - The value to check.
+ * @returns `true` if the value is an `Interval`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isInterval: (v: unknown) => v is Interval;
 declare const make: {
+    /**
+     * Creates a new `Interval` instance.
+     *
+     * @param point - The point of the interval.
+     * @returns A new `Interval` instance.
+     * @since 1.0.0
+     */
     (point: number): Interval;
+    /**
+     * Creates a new `Interval` instance.
+     *
+     * @param start - The start of the interval.
+     * @param end - The end of the interval.
+     * @returns A new `Interval` instance.
+     * @since 1.0.0
+     */
     (start: number, end: number): Interval;
 };
 declare const fromSize: {
+    /**
+     * Creates a new `Interval` instance from a size.
+     *
+     * @param size - The size of the interval.
+     * @returns A new `Interval` instance.
+     * @since 1.0.0
+     */
     (size: number): Interval;
+    /**
+     * Creates a new `Interval` instance from a size.
+     *
+     * @param size - The size of the interval.
+     * @param start - The start of the interval.
+     * @returns A new `Interval` instance.
+     * @since 1.0.0
+     */
     (start: number, size: number): Interval;
 };
+/**
+ * Creates a new `Interval` instance from a minimum and maximum value.
+ *
+ * @param values - The minimum and maximum values of the interval.
+ * @returns A new `Interval` instance.
+ * @since 1.0.0
+ */
 declare const fromMinMax: (...values: ReadonlyArray<number>) => Interval;
+/**
+ * Calculates the size of an interval.
+ *
+ * @param interval - The interval to calculate the size of.
+ * @returns The size of the interval.
+ * @since 1.0.0
+ */
 declare const size: (i: Interval) => number;
 declare const contains: {
+    /**
+     * Checks if a value is contained within an interval.
+     *
+     * @param interval - The interval to check.
+     * @param value - The value to check.
+     * @param options - Options for the check.
+     * @returns `true` if the value is contained within the interval, `false` otherwise.
+     * @since 1.0.0
+     */
     (interval: Interval, value: number, options?: {
         includeStart?: boolean;
         includeEnd?: boolean;
     }): boolean;
+    /**
+     * Checks if a value is contained within an interval.
+     *
+     * @param value - The value to check.
+     * @param options - Options for the check.
+     * @returns A function that takes an interval and returns `true` if the value is contained within the interval, `false` otherwise.
+     * @since 1.0.0
+     */
     (value: number, options?: {
         includeStart?: boolean;
         includeEnd?: boolean;
     }): (interval: Interval) => boolean;
 };
 declare const filter: {
+    /**
+     * Filters a value to be within an interval.
+     *
+     * @param interval - The interval to filter the value to.
+     * @param value - The value to filter.
+     * @param options - Options for the filter.
+     * @returns The filtered value.
+     * @since 1.0.0
+     */
     <V extends ReadonlyArray<number>>(interval: Interval, value: V, options?: {
         includeStart?: boolean;
         includeEnd?: boolean;
     }): V;
+    /**
+     * Filters a value to be within an interval.
+     *
+     * @param value - The value to filter.
+     * @param options - Options for the filter.
+     * @returns A function that takes an interval and returns the filtered value.
+     * @since 1.0.0
+     */
     <V extends ReadonlyArray<number>>(value: V, options?: {
         includeStart?: boolean;
         includeEnd?: boolean;
     }): (interval: Interval) => V;
 };
 declare const clamp: {
+    /**
+     * Clamps a value to be within an interval.
+     *
+     * @param interval - The interval to clamp the value to.
+     * @param value - The value to clamp.
+     * @returns The clamped value.
+     * @since 1.0.0
+     */
     (interval: Interval, value: number): number;
+    /**
+     * Clamps a value to be within an interval.
+     *
+     * @param value - The value to clamp.
+     * @returns A function that takes an interval and returns the clamped value.
+     * @since 1.0.0
+     */
     (value: number): (interval: Interval) => number;
+    /**
+     * Clamps an array of values to be within an interval.
+     *
+     * @param interval - The interval to clamp the values to.
+     * @param value - The values to clamp.
+     * @returns The clamped values.
+     * @since 1.0.0
+     */
     (interval: Interval, value: ReadonlyArray<number>): ReadonlyArray<number>;
+    /**
+     * Clamps an array of values to be within an interval.
+     *
+     * @param value - The values to clamp.
+     * @returns A function that takes an interval and returns the clamped values.
+     * @since 1.0.0
+     */
     (value: ReadonlyArray<number>): (interval: Interval) => ReadonlyArray<number>;
 };
+/**
+ * The unit interval, which is the interval [0, 1].
+ *
+ * @since 1.0.0
+ */
 declare const unit: Interval;
+/**
+ * The biunit interval, which is the interval [-1, 1].
+ *
+ * @since 1.0.0
+ */
 declare const biunit: Interval;
+/**
+ * Linearly interpolates a value within an interval.
+ *
+ * @param interval - The interval to interpolate within.
+ * @param t - The interpolation factor, typically between 0 and 1.
+ * @returns The interpolated value.
+ * @since 1.0.0
+ */
 declare const lerp: (interval: Interval, t: number) => number;
+/**
+ * Creates a linear interpolation function for an interval.
+ *
+ * @param interval - The interval to create the interpolation function for.
+ * @returns A function that takes a factor `t` and returns the interpolated value.
+ * @since 1.0.0
+ */
 declare const toLerpFn: (interval: Interval) => (t: number) => number;
+/**
+ * Normalizes a value within an interval.
+ *
+ * @param interval - The interval to normalize within.
+ * @param x - The value to normalize.
+ * @returns The normalized value.
+ * @since 1.0.0
+ */
 declare const normalize: (interval: Interval, x: number) => number;
+/**
+ * Creates a normalization function for an interval.
+ *
+ * @param interval - The interval to create the normalization function for.
+ * @returns A function that takes a value `x` and returns the normalized value.
+ * @since 1.0.0
+ */
 declare const toNormalizeFn: (interval: Interval) => (x: number) => number;
+/**
+ * Remaps a value from one interval to another.
+ *
+ * @param source - The source interval.
+ * @param target - The target interval.
+ * @param x - The value to remap.
+ * @returns The remapped value.
+ * @since 1.0.0
+ */
 declare const remap: (source: Interval, target: Interval, x: number) => number;
+/**
+ * Creates a remapping function for an interval.
+ *
+ * @param source - The source interval.
+ * @param target - The target interval.
+ * @returns A function that takes a value `x` and returns the remapped value.
+ * @since 1.0.0
+ */
 declare const toRemapFn: (source: Interval, target: Interval) => (x: number) => number;
+/**
+ * Calculates the scale and shift needed to map a source interval to a target interval.
+ *
+ * @param source - The source interval.
+ * @param target - The target interval.
+ * @returns An object containing the scale and shift values.
+ * @since 1.0.0
+ */
+declare const scaleShift: (source: Interval, target: Interval) => ScaleShift;
+/**
+ * The scale and shift needed to map a source interval to a target interval.
+ *
+ * @since 1.0.0
+ */
 interface ScaleShift {
     readonly scale: number;
     readonly shift: number;
 }
-declare const scaleShift: (source: Interval, target: Interval) => ScaleShift;
 
-export { type Interval, type ScaleShift, biunit, clamp, contains, filter, fromMinMax, fromSize, isInterval, lerp, make, normalize, remap, scaleShift, size, toLerpFn, toNormalizeFn, toRemapFn, unit };
+export { biunit, clamp, contains, filter, fromMinMax, fromSize, isInterval, lerp, make, normalize, remap, scaleShift, size, toLerpFn, toNormalizeFn, toRemapFn, unit };
+export type { Interval, ScaleShift };

package/dist/interval.mjs

@@ -1,20 +1,19 @@
 import { dual, Pipeable } from './pipe.mjs';
 import { round } from './utils.mjs';
 
+var _a;
 const TypeId = Symbol.for("curvy/interval");
 class IntervalImpl extends Pipeable {
-  [TypeId] = TypeId;
-  start;
-  end;
   constructor(start = 0, end = start) {
     super();
+    this[_a] = TypeId;
     if (end < start) {
       throw new Error("Interval end must be greater than or equal to start");
     }
     this.start = round(start);
     this.end = round(end);
   }
-  get [Symbol.toStringTag]() {
+  get [(_a = TypeId, Symbol.toStringTag)]() {
     return `Interval [${this.start}, ${this.end}]`;
   }
   get [Symbol.for("nodejs.util.inspect.custom")]() {
@@ -41,15 +40,12 @@ const filter$1 = dual(
     return value.filter((v) => contains$1(interval, v, options));
   }
 );
-const clamp$1 = dual(
-  2,
-  (interval, value) => {
-    if (Array.isArray(value)) {
-      return value.map((v) => clamp$1(interval, v));
-    }
-    return contains$1(interval, value) ? value : value < interval.start ? interval.start : interval.end;
+const clamp$1 = dual(2, (interval, value) => {
+  if (Array.isArray(value)) {
+    return value.map((v) => clamp$1(interval, v));
   }
-);
+  return contains$1(interval, value) ? value : value < interval.start ? interval.start : interval.end;
+});
 const unit$1 = make$1(0, 1);
 const biunit$1 = make$1(-1, 1);
 const lerp$1 = (interval, t) => (1 - t) * interval.start + t * interval.end;
@@ -87,3 +83,4 @@ const toRemapFn = toRemapFn$1;
 const scaleShift = scaleShift$1;
 
 export { biunit, clamp, contains, filter, fromMinMax, fromSize, isInterval, lerp, make, normalize, remap, scaleShift, size, toLerpFn, toNormalizeFn, toRemapFn, unit };
+//# sourceMappingURL=interval.mjs.map

package/dist/interval.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.mjs","sources":["../src/interval.internal.ts","../src/interval.ts"],"sourcesContent":["import type { Interval } from './interval'\nimport { Pipeable } from './pipe'\nimport { dual } from './pipe'\nimport { round } from './utils'\n\nconst TypeId: unique symbol = Symbol.for('curvy/interval')\ntype TypeId = typeof TypeId\n\nclass IntervalImpl extends Pipeable implements Interval {\n  readonly [TypeId]: TypeId = TypeId\n\n  readonly start: number\n  readonly end: number\n\n  constructor(start = 0, end = start) {\n    super()\n\n    if (end < start) {\n      throw new Error('Interval end must be greater than or equal to start')\n    }\n\n    this.start = round(start)\n    this.end = round(end)\n  }\n\n  get [Symbol.toStringTag]() {\n    return `Interval [${this.start}, ${this.end}]`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\nexport const isInterval = (v: unknown): v is Interval =>\n  typeof v === 'object' && v !== null && TypeId in v\n\nexport const make = (start: number, end?: number) => new IntervalImpl(start, end ?? start)\n\nexport const fromSize = (a: number, b?: number) => {\n  if (b === undefined) {\n    return new IntervalImpl(0, a)\n  }\n  return new IntervalImpl(a, a + b)\n}\n\nexport const fromMinMax = (...values: ReadonlyArray<number>) =>\n  new IntervalImpl(Math.min(...values), Math.max(...values))\n\nexport const size = (i: Interval) => Math.abs(i.end - i.start)\n\nexport const contains = dual<\n  (\n    value: number,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ) => (interval: Interval) => boolean,\n  (\n    interval: Interval,\n    value: number,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ) => boolean\n>(\n  (args) => isInterval(args[0]),\n  (interval: Interval, value: number, { includeStart = true, includeEnd = true } = {}) =>\n    (value > interval.start && value < interval.end) ||\n    (includeStart && value === interval.start) ||\n    (includeEnd && value === interval.end),\n)\n\nexport const filter = dual<\n  <V extends ReadonlyArray<number>>(\n    value: V,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ) => (interval: Interval) => V,\n  <V extends ReadonlyArray<number>>(\n    interval: Interval,\n    value: V,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ) => V\n>(\n  (args) => isInterval(args[0]),\n  <V extends ReadonlyArray<number>>(\n    interval: Interval,\n    value: V,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ): V => {\n    return value.filter((v) => contains(interval, v, options)) as unknown as V\n  },\n)\n\nexport const clamp = dual<\n  <V extends number | ReadonlyArray<number>>(value: V) => (interval: Interval) => V,\n  <V extends number | ReadonlyArray<number>>(interval: Interval, value: V) => V\n>(2, <V extends number | ReadonlyArray<number>>(interval: Interval, value: V): V => {\n  if (Array.isArray(value)) {\n    return value.map((v) => clamp(interval, v)) as unknown as V\n  }\n\n  return (\n    contains(interval, value as number)\n      ? (value as number)\n      : (value as number) < interval.start\n        ? interval.start\n        : interval.end\n  ) as V\n})\n\nexport const unit = make(0, 1)\n\nexport const biunit = make(-1, 1)\n\nexport const lerp = (interval: Interval, t: number) => (1 - t) * interval.start + t * interval.end\n\nexport const toLerpFn = (interval: Interval) => (t: number) => lerp(interval, t)\n\nexport const normalize = (interval: Interval, x: number) => (x - interval.start) / size(interval)\n\nexport const toNormalizeFn = (interval: Interval) => (x: number) => normalize(interval, x)\n\nexport const remap = (source: Interval, target: Interval, x: number) => {\n  return target.start + ((x - source.start) * size(target)) / size(source)\n}\n\nexport const toRemapFn = (source: Interval, target: Interval) => (x: number) =>\n  remap(source, target, x)\n\nexport const scaleShift = (source: Interval, target: Interval) => {\n  const scale = size(target) / size(source)\n\n  return {\n    scale,\n    shift: target.start - source.start * scale,\n  }\n}\n","import * as internal from './interval.internal'\nimport type { Pipeable } from './pipe'\n\n/**\n * A mathematical interval.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Interval extends Pipeable {\n  readonly start: number\n  readonly end: number\n}\n\n/**\n * Checks if a value is an `Interval`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is an `Interval`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isInterval: (v: unknown) => v is Interval = internal.isInterval\n\nexport const make: {\n  /**\n   * Creates a new `Interval` instance.\n   *\n   * @param point - The point of the interval.\n   * @returns A new `Interval` instance.\n   * @since 1.0.0\n   */\n  (point: number): Interval\n  /**\n   * Creates a new `Interval` instance.\n   *\n   * @param start - The start of the interval.\n   * @param end - The end of the interval.\n   * @returns A new `Interval` instance.\n   * @since 1.0.0\n   */\n  (start: number, end: number): Interval\n} = internal.make\n\nexport const fromSize: {\n  /**\n   * Creates a new `Interval` instance from a size.\n   *\n   * @param size - The size of the interval.\n   * @returns A new `Interval` instance.\n   * @since 1.0.0\n   */\n  (size: number): Interval\n  /**\n   * Creates a new `Interval` instance from a size.\n   *\n   * @param size - The size of the interval.\n   * @param start - The start of the interval.\n   * @returns A new `Interval` instance.\n   * @since 1.0.0\n   */\n  (start: number, size: number): Interval\n} = internal.fromSize\n\n/**\n * Creates a new `Interval` instance from a minimum and maximum value.\n *\n * @param values - The minimum and maximum values of the interval.\n * @returns A new `Interval` instance.\n * @since 1.0.0\n */\nexport const fromMinMax: (...values: ReadonlyArray<number>) => Interval = internal.fromMinMax\n\n/**\n * Calculates the size of an interval.\n *\n * @param interval - The interval to calculate the size of.\n * @returns The size of the interval.\n * @since 1.0.0\n */\nexport const size: (i: Interval) => number = internal.size\n\nexport const contains: {\n  /**\n   * Checks if a value is contained within an interval.\n   *\n   * @param interval - The interval to check.\n   * @param value - The value to check.\n   * @param options - Options for the check.\n   * @returns `true` if the value is contained within the interval, `false` otherwise.\n   * @since 1.0.0\n   */\n  (\n    interval: Interval,\n    value: number,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ): boolean\n  /**\n   * Checks if a value is contained within an interval.\n   *\n   * @param value - The value to check.\n   * @param options - Options for the check.\n   * @returns A function that takes an interval and returns `true` if the value is contained within the interval, `false` otherwise.\n   * @since 1.0.0\n   */\n  (\n    value: number,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ): (interval: Interval) => boolean\n} = internal.contains\n\nexport const filter: {\n  /**\n   * Filters a value to be within an interval.\n   *\n   * @param interval - The interval to filter the value to.\n   * @param value - The value to filter.\n   * @param options - Options for the filter.\n   * @returns The filtered value.\n   * @since 1.0.0\n   */\n  <V extends ReadonlyArray<number>>(\n    interval: Interval,\n    value: V,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ): V\n  /**\n   * Filters a value to be within an interval.\n   *\n   * @param value - The value to filter.\n   * @param options - Options for the filter.\n   * @returns A function that takes an interval and returns the filtered value.\n   * @since 1.0.0\n   */\n  <V extends ReadonlyArray<number>>(\n    value: V,\n    options?: { includeStart?: boolean; includeEnd?: boolean },\n  ): (interval: Interval) => V\n} = internal.filter\n\nexport const clamp: {\n  /**\n   * Clamps a value to be within an interval.\n   *\n   * @param interval - The interval to clamp the value to.\n   * @param value - The value to clamp.\n   * @returns The clamped value.\n   * @since 1.0.0\n   */\n  (interval: Interval, value: number): number\n  /**\n   * Clamps a value to be within an interval.\n   *\n   * @param value - The value to clamp.\n   * @returns A function that takes an interval and returns the clamped value.\n   * @since 1.0.0\n   */\n  (value: number): (interval: Interval) => number\n  /**\n   * Clamps an array of values to be within an interval.\n   *\n   * @param interval - The interval to clamp the values to.\n   * @param value - The values to clamp.\n   * @returns The clamped values.\n   * @since 1.0.0\n   */\n  (interval: Interval, value: ReadonlyArray<number>): ReadonlyArray<number>\n  /**\n   * Clamps an array of values to be within an interval.\n   *\n   * @param value - The values to clamp.\n   * @returns A function that takes an interval and returns the clamped values.\n   * @since 1.0.0\n   */\n  (value: ReadonlyArray<number>): (interval: Interval) => ReadonlyArray<number>\n} = internal.clamp\n\n/**\n * The unit interval, which is the interval [0, 1].\n *\n * @since 1.0.0\n */\nexport const unit: Interval = internal.unit\n\n/**\n * The biunit interval, which is the interval [-1, 1].\n *\n * @since 1.0.0\n */\nexport const biunit: Interval = internal.biunit\n\n/**\n * Linearly interpolates a value within an interval.\n *\n * @param interval - The interval to interpolate within.\n * @param t - The interpolation factor, typically between 0 and 1.\n * @returns The interpolated value.\n * @since 1.0.0\n */\nexport const lerp: (interval: Interval, t: number) => number = internal.lerp\n\n/**\n * Creates a linear interpolation function for an interval.\n *\n * @param interval - The interval to create the interpolation function for.\n * @returns A function that takes a factor `t` and returns the interpolated value.\n * @since 1.0.0\n */\nexport const toLerpFn: (interval: Interval) => (t: number) => number = internal.toLerpFn\n\n/**\n * Normalizes a value within an interval.\n *\n * @param interval - The interval to normalize within.\n * @param x - The value to normalize.\n * @returns The normalized value.\n * @since 1.0.0\n */\nexport const normalize: (interval: Interval, x: number) => number = internal.normalize\n\n/**\n * Creates a normalization function for an interval.\n *\n * @param interval - The interval to create the normalization function for.\n * @returns A function that takes a value `x` and returns the normalized value.\n * @since 1.0.0\n */\nexport const toNormalizeFn: (interval: Interval) => (x: number) => number = internal.toNormalizeFn\n\n/**\n * Remaps a value from one interval to another.\n *\n * @param source - The source interval.\n * @param target - The target interval.\n * @param x - The value to remap.\n * @returns The remapped value.\n * @since 1.0.0\n */\nexport const remap: (source: Interval, target: Interval, x: number) => number = internal.remap\n\n/**\n * Creates a remapping function for an interval.\n *\n * @param source - The source interval.\n * @param target - The target interval.\n * @returns A function that takes a value `x` and returns the remapped value.\n * @since 1.0.0\n */\nexport const toRemapFn: (source: Interval, target: Interval) => (x: number) => number =\n  internal.toRemapFn\n\n/**\n * Calculates the scale and shift needed to map a source interval to a target interval.\n *\n * @param source - The source interval.\n * @param target - The target interval.\n * @returns An object containing the scale and shift values.\n * @since 1.0.0\n */\nexport const scaleShift: (source: Interval, target: Interval) => ScaleShift = internal.scaleShift\n\n/**\n * The scale and shift needed to map a source interval to a target interval.\n *\n * @since 1.0.0\n */\nexport interface ScaleShift {\n  readonly scale: number\n  readonly shift: number\n}\n"],"names":["isInterval","make","fromSize","fromMinMax","size","contains","filter","clamp","unit","biunit","lerp","toLerpFn","normalize","toNormalizeFn","remap","toRemapFn","scaleShift","internal.isInterval","internal.make","internal.fromSize","internal.fromMinMax","internal.size","internal.contains","internal.filter","internal.clamp","internal.unit","internal.biunit","internal.lerp","internal.toLerpFn","internal.normalize","internal.toNormalizeFn","internal.remap","internal.toRemapFn","internal.scaleShift"],"mappings":"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"}

package/dist/matrix/matrix2x2.d.mts

@@ -5,45 +5,316 @@ import { Vector2 } from '../vector/vector2.mjs';
 declare const Matrix2x2TypeId: unique symbol;
 type Matrix2x2TypeId = typeof Matrix2x2TypeId;
 
+/**
+ * A type representing the coordinate of a 2D matrix.
+ *
+ * @since 1.0.0
+ */
 type Matrix2x2Coordinate = TwoDimensionalIndex | TwoDimensionalComponent;
+/**
+ * A 2D matrix with 2 rows and 2 columns.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface Matrix2x2 extends Pipeable {
     readonly [Matrix2x2TypeId]: Matrix2x2TypeId;
+    /**
+     * The value in the first row and first column.
+     */
     readonly m00: number;
+    /**
+     * The value in the first row and second column.
+     */
     readonly m01: number;
+    /**
+     * The value in the second row and first column.
+     */
     readonly m10: number;
+    /**
+     * The value in the second row and second column.
+     */
     readonly m11: number;
 }
+/**
+ * Checks if a value is a `Matrix2x2`.
+ *
+ * @param m - The value to check.
+ * @returns `true` if the value is a `Matrix2x2`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isMatrix2x2: (m: unknown) => m is Matrix2x2;
-declare const matrix2x2: (m00?: number, m01?: number, m10?: number, m11?: number) => Matrix2x2;
+/**
+ * Creates a new `Matrix2x2` instance.
+ *
+ * @param m00 - The value in the first row and first column. Defaults to 0.
+ * @param m01 - The value in the first row and second column. Defaults to 0.
+ * @param m10 - The value in the second row and first column. Defaults to 0.
+ * @param m11 - The value in the second row and second column. Defaults to 0.
+ */
+declare const make: (m00?: number, m01?: number, m10?: number, m11?: number) => Matrix2x2;
+/**
+ * Creates a new `Matrix2x2` instance from two vectors representing rows.
+ *
+ * @param v0 - The first row vector.
+ * @param v1 - The second row vector.
+ * @returns A new `Matrix2x2` instance.
+ * @since 1.0.0
+ */
 declare const fromRows: (v0: Vector2, v1: Vector2) => Matrix2x2;
+/**
+ * Creates a new `Matrix2x2` instance from two vectors representing columns.
+ *
+ * @param v0 - The first column vector.
+ * @param v1 - The second column vector.
+ * @returns A new `Matrix2x2` instance.
+ * @since 1.0.0
+ */
 declare const fromColumns: (v0: Vector2, v1: Vector2) => Matrix2x2;
 declare const setRow: {
+    /**
+     * Sets the specified row of the matrix to the given vector.
+     *
+     * @param m - The matrix to modify.
+     * @param row - The row index (0 or 1).
+     * @param v - The vector to set the row to.
+     * @returns A new `Matrix2x2` instance with the specified row set to the given vector.
+     * @since 1.0.0
+     */
     (m: Matrix2x2, row: Matrix2x2Coordinate, v: Vector2): Matrix2x2;
+    /**
+     * Sets the specified row of the matrix to the given vector.
+     *
+     * @param row - The row index (0 or 1).
+     * @param v - The vector to set the row to.
+     * @returns A function that takes a matrix and returns a new `Matrix2x2` instance with the specified row set to the given vector.
+     * @since 1.0.0
+     */
     (row: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2;
 };
 declare const setColumn: {
+    /**
+     * Sets the specified column of the matrix to the given vector.
+     *
+     * @param m - The matrix to modify.
+     * @param column - The column index (0 or 1).
+     * @param v - The vector to set the column to.
+     * @returns A new `Matrix2x2` instance with the specified column set to the given vector.
+     * @since 1.0.0
+     */
     (m: Matrix2x2, column: Matrix2x2Coordinate, v: Vector2): Matrix2x2;
+    /**
+     * Sets the specified column of the matrix to the given vector.
+     *
+     * @param column - The column index (0 or 1).
+     * @param v - The vector to set the column to.
+     * @returns A function that takes a matrix and returns a new `Matrix2x2` instance with the specified column set to the given vector.
+     * @since 1.0.0
+     */
     (column: Matrix2x2Coordinate, v: Vector2): (m: Matrix2x2) => Matrix2x2;
 };
+/**
+ * Calculates the determinant of a 2D matrix.
+ *
+ * @param m - The matrix to calculate the determinant for.
+ * @returns The determinant of the matrix.
+ * @since 1.0.0
+ */
 declare const determinant: (m: Matrix2x2) => number;
 declare const vectorProductLeft: {
+    /**
+     * Calculates the left vector product of a matrix and a vector.
+     *
+     * @example
+     * ```ts
+     * import * as Matrix2x2 from 'curvy/matrix2x2'
+     * import * as Vector2 from 'curvy/vector2'
+     *
+     * const matrix = Matrix2x2.make(1, 2, 3, 4)
+     * const vector = Vector2.make(5, 6)
+     *
+     * // Performs:
+     * // x = 1 * 5 + 2 * 6 = 17
+     * // y = 3 * 5 + 4 * 6 = 39
+     * const result = Matrix2x2.vectorProductLeft(matrix, vector)
+     * ```
+     * @param m - The matrix to multiply.
+     * @param v - The vector to multiply.
+     * @returns The resulting vector after the left vector product.
+     * @since 1.0.0
+     */
     (m: Matrix2x2, v: Vector2): Vector2;
+    /**
+     * Calculates the left vector product of a matrix and a vector.
+     *
+     * @example
+     * ```ts
+     * import * as Matrix2x2 from 'curvy/matrix2x2'
+     * import * as Vector2 from 'curvy/vector2'
+     *
+     * const matrix = Matrix2x2.make(1, 2, 3, 4)
+     * const vector = Vector2.make(5, 6)
+     *
+     * // Performs:
+     * // x = 1 * 5 + 2 * 6 = 17
+     * // y = 3 * 5 + 4 * 6 = 39
+     * const result = Matrix2x2.vectorProductLeft(vector)(matrix)
+     * ```
+     * @param v - The vector to multiply.
+     * @returns A function that takes a matrix and returns the resulting vector after the left vector product.
+     * @since 1.0.0
+     */
     (v: Vector2): (m: Matrix2x2) => Vector2;
 };
 declare const vectorProductRight: {
+    /**
+     * Calculates the right vector product of a matrix and a vector.
+     *
+     * @example
+     * ```ts
+     * import * as Matrix2x2 from 'curvy/matrix2x2'
+     * import * as Vector2 from 'curvy/vector2'
+     *
+     * const matrix = Matrix2x2.make(1, 2, 3, 4)
+     * const vector = Vector2.make(5, 6)
+     *
+     * // Performs:
+     * // x = 1 * 5 + 3 * 6 = 33
+     * // y = 2 * 5 + 4 * 6 = 62
+     * const result = Matrix2x2.vectorProductRight(matrix, vector)
+     * ```
+     * @param m - The matrix to multiply.
+     * @param v - The vector to multiply.
+     * @returns The resulting vector after the right vector product.
+     * @since 1.0.0
+     */
     (m: Matrix2x2, v: Vector2): Vector2;
+    /**
+     * Calculates the right vector product of a matrix and a vector.
+     *
+     * @example
+     * ```ts
+     * import * as Matrix2x2 from 'curvy/matrix2x2'
+     * import * as Vector2 from 'curvy/vector2'
+     *
+     * const matrix = Matrix2x2.make(1, 2, 3, 4)
+     * const vector = Vector2.make(5, 6)
+     *
+     * // Performs:
+     * // x = 1 * 5 + 3 * 6 = 33
+     * // y = 2 * 5 + 4 * 6 = 62
+     * const result = Matrix2x2.vectorProductRight(vector)(matrix)
+     * ```
+     * @param v - The vector to multiply.
+     * @returns A function that takes a matrix and returns the resulting vector after the right vector product.
+     * @since 1.0.0
+     */
     (v: Vector2): (m: Matrix2x2) => Vector2;
 };
 declare const solveSystem: {
+    /**
+     * Solves a system of linear equations represented by a matrix and a vector.
+     *
+     * @example
+     * ```ts
+     * import * as Matrix2x2 from 'curvy/matrix2x2'
+     * import * as Vector2 from 'curvy/vector2'
+     *
+     * const matrix = Matrix2x2.make(1, 2, 3, 4)
+     * const vector = Vector2.make(5, 6)
+     *
+     * // Solves the system of equations:
+     * // 1x + 2y = 5
+     * // 3x + 4y = 6
+     * const result = Matrix2x2.solveSystem(matrix, vector)
+     * ```
+     * @param m - The matrix representing the coefficients of the system.
+     * @param v - The vector representing the constants of the system.
+     * @returns The solution vector.
+     * @since 1.0.0
+     */
     (m: Matrix2x2, v: Vector2): Vector2;
+    /**
+     * Solves a system of linear equations represented by a matrix and a vector.
+     *
+     * @example
+     * ```ts
+     * import * as Matrix2x2 from 'curvy/matrix2x2'
+     * import * as Vector2 from 'curvy/vector2'
+     *
+     * const matrix = Matrix2x2.make(1, 2, 3, 4)
+     * const vector = Vector2.make(5, 6)
+     *
+     * // Solves the system of equations:
+     * // 1x + 2y = 5
+     * // 3x + 4y = 6
+     * const result = Matrix2x2.solveSystem(vector)(matrix)
+     * ```
+     * @param v - The vector representing the constants of the system.
+     * @returns A function that takes a matrix and returns the solution vector.
+     * @since 1.0.0
+     */
     (v: Vector2): (m: Matrix2x2) => Vector2;
 };
+/**
+ * Returns the rows of a matrix 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
+ */
 declare const toRows: (m: Matrix2x2) => [Vector2, Vector2];
+/**
+ * Returns the columns of a matrix 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
+ */
 declare const toColumns: (m: Matrix2x2) => [Vector2, Vector2];
+/**
+ * Returns the specified row of a matrix as a vector.
+ *
+ * @param m - The matrix to get the row from.
+ * @param row - The row index (0 or 1).
+ * @returns A vector representing the specified row of the matrix.
+ * @since 1.0.0
+ */
 declare const rowVector: (m: Matrix2x2, row: Matrix2x2Coordinate) => Vector2;
+/**
+ * Returns the specified column of a matrix as a vector.
+ *
+ * @param m - The matrix to get the column from.
+ * @param column - The column index (0 or 1).
+ * @returns A vector representing the specified column of the matrix.
+ * @since 1.0.0
+ */
 declare const columnVector: (m: Matrix2x2, column: Matrix2x2Coordinate) => Vector2;
+/**
+ * Transposes a matrix.
+ *
+ * @param m - The matrix to transpose.
+ * @returns A new `Matrix2x2` instance representing the transposed matrix.
+ * @since 1.0.0
+ */
 declare const transpose: (m: Matrix2x2) => Matrix2x2;
+/**
+ * Reverses the rows of a matrix.
+ *
+ * @param m - The matrix to reverse the rows of.
+ * @returns A new `Matrix2x2` instance with the rows reversed.
+ * @since 1.0.0
+ */
 declare const reverseRows: (m: Matrix2x2) => Matrix2x2;
+/**
+ * Reverses the columns of a matrix.
+ *
+ * @param m - The matrix to reverse the columns of.
+ * @returns A new `Matrix2x2` instance with the columns reversed.
+ * @since 1.0.0
+ */
 declare const reverseColumns: (m: Matrix2x2) => Matrix2x2;
 
-export { type Matrix2x2, type Matrix2x2Coordinate, columnVector, determinant, fromColumns, fromRows, isMatrix2x2, matrix2x2, reverseColumns, reverseRows, rowVector, setColumn, setRow, solveSystem, toColumns, toRows, transpose, vectorProductLeft, vectorProductRight };
+export { columnVector, determinant, fromColumns, fromRows, isMatrix2x2, make, reverseColumns, reverseRows, rowVector, setColumn, setRow, solveSystem, toColumns, toRows, transpose, vectorProductLeft, vectorProductRight };
+export type { Matrix2x2, Matrix2x2Coordinate };