curvy 1.0.8 → 2.0.0-alpha.0

package/dist/number.d.mts

@@ -0,0 +1,280 @@
+//#region src/number.d.ts
+/**
+ * Default tolerance for approximate equality between floating-point numbers.
+ *
+ * @since 1.1.0
+ */
+declare const EPSILON = 1e-10;
+/**
+ * Approximate equality between two numbers, within an absolute tolerance.
+ *
+ * @param a - The first value.
+ * @param b - The second value.
+ * @param eps - The maximum allowed absolute difference. Defaults to {@link EPSILON}.
+ * @returns `true` when `|a - b| <= eps`.
+ * @since 1.1.0
+ */
+declare function epsEquals(a: number, b: number, eps?: number): boolean;
+/**
+ * Snaps near-zero values to exactly zero for stable sign tests.
+ *
+ * @param value - The value to test.
+ * @param eps - The threshold below which `value` is considered zero.
+ * @returns `0` when `|value| < eps`, otherwise `value` unchanged.
+ * @since 1.1.0
+ */
+declare function clampToZero(value: number, eps: number): number;
+/**
+ * Rounding function that rounds a number to a specified precision.
+ *
+ * @param value - The number to round.
+ * @param precision - The number of decimal places to round to (default is 8).
+ * @returns The rounded number.
+ * @example
+ * ```ts
+ * import { round } from 'curvy/utils'
+ *
+ * const roundedValue = round(1.23456789, 4) // 1.2346
+ * const roundedValue2 = round(1.23456789) // 1.23456789
+ * ```
+ * @since 1.0.0
+ */
+declare function round(value: number, precision?: number): number;
+/**
+ * Rounding function that rounds a number down to a specified precision.
+ *
+ * @param value - The number to round down.
+ * @param precision - The number of decimal places to round down to (default is 8).
+ * @returns The rounded down number.
+ * @example
+ * ```ts
+ * import { roundDown } from 'curvy/utils'
+ *
+ * const roundedDownValue = roundDown(1.23456789, 4) // 1.2345
+ * const roundedDownValue2 = roundDown(1.23456789) // 1.23456789
+ * ```
+ * @since 1.0.0
+ */
+declare function roundDown(value: number, precision?: number): number;
+/**
+ * Rounding function that rounds a number up to a specified precision.
+ *
+ * @param value - The number to round up.
+ * @param precision - The number of decimal places to round up to (default is 8).
+ * @returns The rounded up number.
+ * @example
+ * ```ts
+ * import { roundUp } from 'curvy/utils'
+ *
+ * const roundedUpValue = roundUp(1.23456789, 4) // 1.2346
+ * const roundedUpValue2 = roundUp(1.23456789) // 1.23456789
+ * ```
+ * @since 1.0.0
+ */
+declare function roundUp(value: number, precision?: number): number;
+declare const lerp: {
+  /**
+   * Linearly interpolates between two values.
+   *
+   * @param t - The interpolation factor (between 0 and 1).
+   * @param a - The start value.
+   * @param b - The end value.
+   * @returns The interpolated value.
+   * @example
+   * ```ts
+   * import { lerp } from 'curvy/utils'
+   *
+   * lerp(0.5, 10, 20) // 15
+   * ```
+   * @since 1.0.0
+   */
+  (t: number, a: number, b: number): number;
+  /**
+   * Linearly interpolates between two values.
+   *
+   * @param a - The start value.
+   * @param b - The end value.
+   * @returns A function that takes the interpolation factor and returns the interpolated value.
+   * @example
+   * ```ts
+   * import { lerp } from 'curvy/utils'
+   *
+   * lerp(10, 20)(0.5) // 15
+   * ```
+   * @since 1.0.0
+   */
+  (a: number, b: number): (t: number) => number;
+};
+declare const normalize: {
+  /**
+   * Normalizes a value between two bounds to the unit interval.
+   *
+   * @param x - The value to normalize.
+   * @param a - The lower bound.
+   * @param b - The upper bound.
+   * @returns The normalized value.
+   * @example
+   * ```ts
+   * import { normalize } from 'curvy/utils'
+   *
+   * normalize(15, 10, 20) // 0.5
+   * ```
+   * @since 1.0.0
+   */
+  (x: number, a: number, b: number): number;
+  /**
+   * Normalizes a value between two bounds to the unit interval.
+   *
+   * @param a - The lower bound.
+   * @param b - The upper bound.
+   * @returns A function that takes a value and returns the normalized value.
+   * @example
+   * ```ts
+   * import { normalize } from 'curvy/utils'
+   *
+   * normalize(10, 20)(15) // 0.5
+   * ```
+   * @since 1.0.0
+   */
+  (a: number, b: number): (x: number) => number;
+};
+declare const remap: {
+  /**
+   * Remaps a value from one range to another.
+   *
+   * @param x - The value to remap.
+   * @param x1 - The lower bound of the original range.
+   * @param x2 - The upper bound of the original range.
+   * @param y1 - The lower bound of the new range.
+   * @param y2 - The upper bound of the new range.
+   * @returns The remapped value.
+   * @example
+   * ```ts
+   * import { remap } from 'curvy/utils'
+   *
+   * remap(15, 10, 20, 0, 100) // 50
+   * ```
+   * @since 1.0.0
+   */
+  (x: number, x1: number, x2: number, y1: number, y2: number): number;
+  /**
+   * Remaps a value from one range to another.
+   *
+   * @param x1 - The lower bound of the original range.
+   * @param x2 - The upper bound of the original range.
+   * @param y1 - The lower bound of the new range.
+   * @param y2 - The upper bound of the new range.
+   * @returns A function that takes a value and returns the remapped value.
+   * @example
+   * ```ts
+   * import { remap } from 'curvy/utils'
+   *
+   * remap(10, 20, 0, 100)(15) // 50
+   * ```
+   * @since 1.0.0
+   */
+  (x1: number, x2: number, y1: number, y2: number): (x: number) => number;
+};
+declare const clamp: {
+  /**
+   * Clamps a value between two bounds.
+   *
+   * @param value - The value to clamp.
+   * @param min - The lower bound.
+   * @param max - The upper bound.
+   * @returns The clamped value.
+   * @example
+   * ```ts
+   * import { clamp } from 'curvy/utils'
+   *
+   * clamp(25, 10, 20) // 20
+   * ```
+   * @since 1.0.0
+   */
+  (value: number, min: number, max: number): number;
+  /**
+   * Clamps a value between two bounds.
+   *
+   * @param min - The lower bound.
+   * @param max - The upper bound.
+   * @returns A function that takes a value and returns the clamped value.
+   * @example
+   * ```ts
+   * import { clamp } from 'curvy/utils'
+   *
+   * clamp(10, 20)(25) // 20
+   * ```
+   * @since 1.0.0
+   */
+  (min: number, max: number): (value: number) => number;
+};
+declare const clip: {
+  /**
+   * Clips a value to a specified range, returning a fallback value if the value is outside the range.
+   *
+   * @param value - The value to clip.
+   * @param min - The lower bound.
+   * @param max - The upper bound.
+   * @param onClip - The fallback value to return if the value is outside the range.
+   * @returns The original value if within range, otherwise the fallback.
+   * @example
+   * ```ts
+   * import { clip } from 'curvy/utils'
+   *
+   * clip(25, 10, 20, 15) // 15
+   * ```
+   * @since 1.0.0
+   */
+  <T>(value: number, min: number, max: number, onClip: T): T | number;
+  /**
+   * Clips a value to a specified range, returning a fallback value if the value is outside the range.
+   *
+   * @param min - The lower bound.
+   * @param max - The upper bound.
+   * @param onClip - The fallback value to return if the value is outside the range.
+   * @returns A function that takes a value and returns it if within range, otherwise the fallback.
+   * @example
+   * ```ts
+   * import { clip } from 'curvy/utils'
+   *
+   * clip(10, 20, 15)(25) // 15
+   * ```
+   * @since 1.0.0
+   */
+  <T>(min: number, max: number, onClip: T): (value: number) => T | number;
+};
+/**
+ * Returns the minimum and maximum of two numbers.
+ *
+ * @param a - The first number.
+ * @param b - The second number.
+ * @returns A tuple containing the minimum and maximum values.
+ * @example
+ * ```ts
+ * import { minMax } from 'curvy/utils'
+ *
+ * const [minValue, maxValue] = minMax(10, 20) // [10, 20]
+ * const [minValue2, maxValue2] = minMax(20, 10) // [10, 20]
+ * ```
+ * @since 1.0.0
+ */
+declare function minMax(a: number, b: number): [number, number];
+/**
+ * Calculates the modulus of a number.
+ *
+ * @param n - The number to calculate the modulus of.
+ * @param m - The modulus.
+ * @returns The modulus of the number.
+ * @example
+ * ```ts
+ * import { mod } from 'curvy/utils'
+ *
+ * const modulus = mod(10, 3) // 1
+ * const modulus2 = mod(-10, 3) // 2
+ * ```
+ * @since 1.0.0
+ */
+declare function mod(n: number, m: number): number;
+//#endregion
+export { EPSILON, clamp, clampToZero, clip, epsEquals, lerp, minMax, mod, normalize, remap, round, roundDown, roundUp };
+//# sourceMappingURL=number.d.mts.map

package/dist/number.mjs

@@ -0,0 +1,140 @@
+import { dual } from "./utils.mjs";
+//#region src/number.ts
+const PRECISION = 8;
+/**
+* Default tolerance for approximate equality between floating-point numbers.
+*
+* @since 1.1.0
+*/
+const EPSILON = 1e-10;
+/**
+* Approximate equality between two numbers, within an absolute tolerance.
+*
+* @param a - The first value.
+* @param b - The second value.
+* @param eps - The maximum allowed absolute difference. Defaults to {@link EPSILON}.
+* @returns `true` when `|a - b| <= eps`.
+* @since 1.1.0
+*/
+function epsEquals(a, b, eps = EPSILON) {
+	return Math.abs(a - b) <= eps;
+}
+/**
+* Snaps near-zero values to exactly zero for stable sign tests.
+*
+* @param value - The value to test.
+* @param eps - The threshold below which `value` is considered zero.
+* @returns `0` when `|value| < eps`, otherwise `value` unchanged.
+* @since 1.1.0
+*/
+function clampToZero(value, eps) {
+	return Math.abs(value) < eps ? 0 : value;
+}
+/**
+* Rounding function that rounds a number to a specified precision.
+*
+* @param value - The number to round.
+* @param precision - The number of decimal places to round to (default is 8).
+* @returns The rounded number.
+* @example
+* ```ts
+* import { round } from 'curvy/utils'
+*
+* const roundedValue = round(1.23456789, 4) // 1.2346
+* const roundedValue2 = round(1.23456789) // 1.23456789
+* ```
+* @since 1.0.0
+*/
+function round(value, precision = PRECISION) {
+	const scale = 10 ** precision;
+	const result = Math.round(value * scale) / scale;
+	if (result === 0) return 0;
+	return result;
+}
+/**
+* Rounding function that rounds a number down to a specified precision.
+*
+* @param value - The number to round down.
+* @param precision - The number of decimal places to round down to (default is 8).
+* @returns The rounded down number.
+* @example
+* ```ts
+* import { roundDown } from 'curvy/utils'
+*
+* const roundedDownValue = roundDown(1.23456789, 4) // 1.2345
+* const roundedDownValue2 = roundDown(1.23456789) // 1.23456789
+* ```
+* @since 1.0.0
+*/
+function roundDown(value, precision = PRECISION) {
+	const scale = 10 ** precision;
+	const result = Math.floor(value * scale) / scale;
+	if (result === 0) return 0;
+	return result;
+}
+/**
+* Rounding function that rounds a number up to a specified precision.
+*
+* @param value - The number to round up.
+* @param precision - The number of decimal places to round up to (default is 8).
+* @returns The rounded up number.
+* @example
+* ```ts
+* import { roundUp } from 'curvy/utils'
+*
+* const roundedUpValue = roundUp(1.23456789, 4) // 1.2346
+* const roundedUpValue2 = roundUp(1.23456789) // 1.23456789
+* ```
+* @since 1.0.0
+*/
+function roundUp(value, precision = PRECISION) {
+	const scale = 10 ** precision;
+	const result = Math.ceil(value * scale) / scale;
+	if (result === 0) return 0;
+	return result;
+}
+const lerp = dual(3, (t, a, b) => b * t + a * (1 - t));
+const normalize = dual(3, (x, a, b) => (x - a) / (b - a));
+const remap = dual(5, (x, x1, x2, y1, y2) => y1 + (x - x1) / (x2 - x1) * (y2 - y1));
+const clamp = dual(3, (value, min, max) => value < min ? min : value > max ? max : value);
+const clip = dual(4, (value, min, max, onClip) => value < min ? onClip : value > max ? onClip : value);
+/**
+* Returns the minimum and maximum of two numbers.
+*
+* @param a - The first number.
+* @param b - The second number.
+* @returns A tuple containing the minimum and maximum values.
+* @example
+* ```ts
+* import { minMax } from 'curvy/utils'
+*
+* const [minValue, maxValue] = minMax(10, 20) // [10, 20]
+* const [minValue2, maxValue2] = minMax(20, 10) // [10, 20]
+* ```
+* @since 1.0.0
+*/
+function minMax(a, b) {
+	return a < b ? [a, b] : [b, a];
+}
+/**
+* Calculates the modulus of a number.
+*
+* @param n - The number to calculate the modulus of.
+* @param m - The modulus.
+* @returns The modulus of the number.
+* @example
+* ```ts
+* import { mod } from 'curvy/utils'
+*
+* const modulus = mod(10, 3) // 1
+* const modulus2 = mod(-10, 3) // 2
+* ```
+* @since 1.0.0
+*/
+function mod(n, m) {
+	return (n % m + m) % m;
+}
+//#endregion
+export { EPSILON, clamp, clampToZero, clip, epsEquals, lerp, minMax, mod, normalize, remap, round, roundDown, roundUp };
+
+//# sourceMappingURL=number.mjs.map

package/dist/number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.mjs","names":[],"sources":["../src/number.ts"],"sourcesContent":["import { dual } from './utils'\n\nconst PRECISION = 8\n\n/**\n * Default tolerance for approximate equality between floating-point numbers.\n *\n * @since 1.1.0\n */\nexport const EPSILON = 1e-10\n\n/**\n * Approximate equality between two numbers, within an absolute tolerance.\n *\n * @param a - The first value.\n * @param b - The second value.\n * @param eps - The maximum allowed absolute difference. Defaults to {@link EPSILON}.\n * @returns `true` when `|a - b| <= eps`.\n * @since 1.1.0\n */\nexport function epsEquals(a: number, b: number, eps: number = EPSILON): boolean {\n  return Math.abs(a - b) <= eps\n}\n\n/**\n * Snaps near-zero values to exactly zero for stable sign tests.\n *\n * @param value - The value to test.\n * @param eps - The threshold below which `value` is considered zero.\n * @returns `0` when `|value| < eps`, otherwise `value` unchanged.\n * @since 1.1.0\n */\nexport function clampToZero(value: number, eps: number): number {\n  return Math.abs(value) < eps ? 0 : value\n}\n\n/**\n * Rounding function that rounds a number to a specified precision.\n *\n * @param value - The number to round.\n * @param precision - The number of decimal places to round to (default is 8).\n * @returns The rounded number.\n * @example\n * ```ts\n * import { round } from 'curvy/utils'\n *\n * const roundedValue = round(1.23456789, 4) // 1.2346\n * const roundedValue2 = round(1.23456789) // 1.23456789\n * ```\n * @since 1.0.0\n */\nexport function round(value: number, precision = PRECISION): number {\n  const scale = 10 ** precision\n  const result = Math.round(value * scale) / scale\n  if (result === 0) {\n    return 0\n  }\n  return result\n}\n\n/**\n * Rounding function that rounds a number down to a specified precision.\n *\n * @param value - The number to round down.\n * @param precision - The number of decimal places to round down to (default is 8).\n * @returns The rounded down number.\n * @example\n * ```ts\n * import { roundDown } from 'curvy/utils'\n *\n * const roundedDownValue = roundDown(1.23456789, 4) // 1.2345\n * const roundedDownValue2 = roundDown(1.23456789) // 1.23456789\n * ```\n * @since 1.0.0\n */\nexport function roundDown(value: number, precision = PRECISION): number {\n  const scale = 10 ** precision\n  const result = Math.floor(value * scale) / scale\n  if (result === 0) {\n    return 0\n  }\n  return result\n}\n\n/**\n * Rounding function that rounds a number up to a specified precision.\n *\n * @param value - The number to round up.\n * @param precision - The number of decimal places to round up to (default is 8).\n * @returns The rounded up number.\n * @example\n * ```ts\n * import { roundUp } from 'curvy/utils'\n *\n * const roundedUpValue = roundUp(1.23456789, 4) // 1.2346\n * const roundedUpValue2 = roundUp(1.23456789) // 1.23456789\n * ```\n * @since 1.0.0\n */\nexport function roundUp(value: number, precision = PRECISION): number {\n  const scale = 10 ** precision\n  const result = Math.ceil(value * scale) / scale\n  if (result === 0) {\n    return 0\n  }\n  return result\n}\n\nexport const lerp: {\n  /**\n   * Linearly interpolates between two values.\n   *\n   * @param t - The interpolation factor (between 0 and 1).\n   * @param a - The start value.\n   * @param b - The end value.\n   * @returns The interpolated value.\n   * @example\n   * ```ts\n   * import { lerp } from 'curvy/utils'\n   *\n   * lerp(0.5, 10, 20) // 15\n   * ```\n   * @since 1.0.0\n   */\n  (t: number, a: number, b: number): number\n  /**\n   * Linearly interpolates between two values.\n   *\n   * @param a - The start value.\n   * @param b - The end value.\n   * @returns A function that takes the interpolation factor and returns the interpolated value.\n   * @example\n   * ```ts\n   * import { lerp } from 'curvy/utils'\n   *\n   * lerp(10, 20)(0.5) // 15\n   * ```\n   * @since 1.0.0\n   */\n  (a: number, b: number): (t: number) => number\n} = dual(3, (t: number, a: number, b: number) => b * t + a * (1 - t))\n\nexport const normalize: {\n  /**\n   * Normalizes a value between two bounds to the unit interval.\n   *\n   * @param x - The value to normalize.\n   * @param a - The lower bound.\n   * @param b - The upper bound.\n   * @returns The normalized value.\n   * @example\n   * ```ts\n   * import { normalize } from 'curvy/utils'\n   *\n   * normalize(15, 10, 20) // 0.5\n   * ```\n   * @since 1.0.0\n   */\n  (x: number, a: number, b: number): number\n  /**\n   * Normalizes a value between two bounds to the unit interval.\n   *\n   * @param a - The lower bound.\n   * @param b - The upper bound.\n   * @returns A function that takes a value and returns the normalized value.\n   * @example\n   * ```ts\n   * import { normalize } from 'curvy/utils'\n   *\n   * normalize(10, 20)(15) // 0.5\n   * ```\n   * @since 1.0.0\n   */\n  (a: number, b: number): (x: number) => number\n} = dual(3, (x: number, a: number, b: number) => (x - a) / (b - a))\n\nexport const remap: {\n  /**\n   * Remaps a value from one range to another.\n   *\n   * @param x - The value to remap.\n   * @param x1 - The lower bound of the original range.\n   * @param x2 - The upper bound of the original range.\n   * @param y1 - The lower bound of the new range.\n   * @param y2 - The upper bound of the new range.\n   * @returns The remapped value.\n   * @example\n   * ```ts\n   * import { remap } from 'curvy/utils'\n   *\n   * remap(15, 10, 20, 0, 100) // 50\n   * ```\n   * @since 1.0.0\n   */\n  (x: number, x1: number, x2: number, y1: number, y2: number): number\n  /**\n   * Remaps a value from one range to another.\n   *\n   * @param x1 - The lower bound of the original range.\n   * @param x2 - The upper bound of the original range.\n   * @param y1 - The lower bound of the new range.\n   * @param y2 - The upper bound of the new range.\n   * @returns A function that takes a value and returns the remapped value.\n   * @example\n   * ```ts\n   * import { remap } from 'curvy/utils'\n   *\n   * remap(10, 20, 0, 100)(15) // 50\n   * ```\n   * @since 1.0.0\n   */\n  (x1: number, x2: number, y1: number, y2: number): (x: number) => number\n} = dual(\n  5,\n  (x: number, x1: number, x2: number, y1: number, y2: number) =>\n    y1 + ((x - x1) / (x2 - x1)) * (y2 - y1),\n)\n\nexport const clamp: {\n  /**\n   * Clamps a value between two bounds.\n   *\n   * @param value - The value to clamp.\n   * @param min - The lower bound.\n   * @param max - The upper bound.\n   * @returns The clamped value.\n   * @example\n   * ```ts\n   * import { clamp } from 'curvy/utils'\n   *\n   * clamp(25, 10, 20) // 20\n   * ```\n   * @since 1.0.0\n   */\n  (value: number, min: number, max: number): number\n  /**\n   * Clamps a value between two bounds.\n   *\n   * @param min - The lower bound.\n   * @param max - The upper bound.\n   * @returns A function that takes a value and returns the clamped value.\n   * @example\n   * ```ts\n   * import { clamp } from 'curvy/utils'\n   *\n   * clamp(10, 20)(25) // 20\n   * ```\n   * @since 1.0.0\n   */\n  (min: number, max: number): (value: number) => number\n} = dual(3, (value: number, min: number, max: number) =>\n  value < min ? min : value > max ? max : value,\n)\n\nexport const clip: {\n  /**\n   * Clips a value to a specified range, returning a fallback value if the value is outside the range.\n   *\n   * @param value - The value to clip.\n   * @param min - The lower bound.\n   * @param max - The upper bound.\n   * @param onClip - The fallback value to return if the value is outside the range.\n   * @returns The original value if within range, otherwise the fallback.\n   * @example\n   * ```ts\n   * import { clip } from 'curvy/utils'\n   *\n   * clip(25, 10, 20, 15) // 15\n   * ```\n   * @since 1.0.0\n   */\n  <T>(value: number, min: number, max: number, onClip: T): T | number\n  /**\n   * Clips a value to a specified range, returning a fallback value if the value is outside the range.\n   *\n   * @param min - The lower bound.\n   * @param max - The upper bound.\n   * @param onClip - The fallback value to return if the value is outside the range.\n   * @returns A function that takes a value and returns it if within range, otherwise the fallback.\n   * @example\n   * ```ts\n   * import { clip } from 'curvy/utils'\n   *\n   * clip(10, 20, 15)(25) // 15\n   * ```\n   * @since 1.0.0\n   */\n  <T>(min: number, max: number, onClip: T): (value: number) => T | number\n} = dual(4, (value: number, min: number, max: number, onClip: unknown) =>\n  value < min ? onClip : value > max ? onClip : value,\n)\n\n/**\n * Returns the minimum and maximum of two numbers.\n *\n * @param a - The first number.\n * @param b - The second number.\n * @returns A tuple containing the minimum and maximum values.\n * @example\n * ```ts\n * import { minMax } from 'curvy/utils'\n *\n * const [minValue, maxValue] = minMax(10, 20) // [10, 20]\n * const [minValue2, maxValue2] = minMax(20, 10) // [10, 20]\n * ```\n * @since 1.0.0\n */\nexport function minMax(a: number, b: number): [number, number] {\n  return a < b ? [a, b] : [b, a]\n}\n\n/**\n * Calculates the modulus of a number.\n *\n * @param n - The number to calculate the modulus of.\n * @param m - The modulus.\n * @returns The modulus of the number.\n * @example\n * ```ts\n * import { mod } from 'curvy/utils'\n *\n * const modulus = mod(10, 3) // 1\n * const modulus2 = mod(-10, 3) // 2\n * ```\n * @since 1.0.0\n */\nexport function mod(n: number, m: number): number {\n  return ((n % m) + m) % m\n}\n\n"],"mappings":";;AAEA,MAAM,YAAY;;;;;;AAOlB,MAAa,UAAU;;;;;;;;;;AAWvB,SAAgB,UAAU,GAAW,GAAW,MAAc,SAAkB;CAC9E,OAAO,KAAK,IAAI,IAAI,EAAE,IAAI;;;;;;;;;;AAW5B,SAAgB,YAAY,OAAe,KAAqB;CAC9D,OAAO,KAAK,IAAI,MAAM,GAAG,MAAM,IAAI;;;;;;;;;;;;;;;;;AAkBrC,SAAgB,MAAM,OAAe,YAAY,WAAmB;CAClE,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,KAAK,MAAM,QAAQ,MAAM,GAAG;CAC3C,IAAI,WAAW,GACb,OAAO;CAET,OAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,UAAU,OAAe,YAAY,WAAmB;CACtE,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,KAAK,MAAM,QAAQ,MAAM,GAAG;CAC3C,IAAI,WAAW,GACb,OAAO;CAET,OAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,QAAQ,OAAe,YAAY,WAAmB;CACpE,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,KAAK,KAAK,QAAQ,MAAM,GAAG;CAC1C,IAAI,WAAW,GACb,OAAO;CAET,OAAO;;AAGT,MAAa,OAgCT,KAAK,IAAI,GAAW,GAAW,MAAc,IAAI,IAAI,KAAK,IAAI,GAAG;AAErE,MAAa,YAgCT,KAAK,IAAI,GAAW,GAAW,OAAe,IAAI,MAAM,IAAI,GAAG;AAEnE,MAAa,QAoCT,KACF,IACC,GAAW,IAAY,IAAY,IAAY,OAC9C,MAAO,IAAI,OAAO,KAAK,OAAQ,KAAK,IACvC;AAED,MAAa,QAgCT,KAAK,IAAI,OAAe,KAAa,QACvC,QAAQ,MAAM,MAAM,QAAQ,MAAM,MAAM,MACzC;AAED,MAAa,OAkCT,KAAK,IAAI,OAAe,KAAa,KAAa,WACpD,QAAQ,MAAM,SAAS,QAAQ,MAAM,SAAS,MAC/C;;;;;;;;;;;;;;;;AAiBD,SAAgB,OAAO,GAAW,GAA6B;CAC7D,OAAO,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE;;;;;;;;;;;;;;;;;AAkBhC,SAAgB,IAAI,GAAW,GAAmB;CAChD,QAAS,IAAI,IAAK,KAAK"}

package/dist/path/index.d.mts

@@ -0,0 +1,241 @@
+import { t as Vector2 } from "../shared/vector2-TV0UnlxY.mjs";
+import { t as Pipeable } from "../shared/utils-DqTGyXrP.mjs";
+import { a as QuadraticCurve2d, s as LinearCurve2d } from "../shared/rationalCubic2d-BPLohNuI.mjs";
+import { a as Continuous, i as cubic2d_d_exports, n as rationalCubic2d_d_exports, o as PathTraits } from "../shared/rationalCubic2d-D_-XWxcm.mjs";
+
+//#region src/path/linear2d.internal.d.ts
+declare const LinearPath2dTypeId: unique symbol;
+type LinearPath2dTypeId = typeof LinearPath2dTypeId;
+declare namespace linear2d_d_exports {
+  export { Continuous, LinearPath2d, append$1 as append, asContinuous$1 as asContinuous, fromArray$1 as fromArray, isContinuous$1 as isContinuous, isLinearPath2d, length$1 as length, make$1 as make, solve$1 as solve, toPathData$1 as toPathData };
+}
+/**
+ * A linear path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Trait` type parameter accumulates trait brands as the path is refined
+ * via `isContinuous` / `asContinuous`. A `Continuous` path's `toPathData`
+ * skips the per-segment discontinuity check.
+ *
+ * @since 1.0.0
+ */
+interface LinearPath2d<out Trait = unknown> extends Pipeable, Iterable<LinearCurve2d> {
+  readonly [LinearPath2dTypeId]: LinearPath2dTypeId;
+  readonly [PathTraits]: Trait;
+}
+/**
+ * Creates a new `LinearPath2d` instance from a sequence of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `LinearPath2d` instance.
+ * @since 2.0.0
+ */
+declare const make$1: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * Creates a new `LinearPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `LinearPath2d` instance.
+ * @since 2.0.0
+ */
+declare const fromArray$1: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * Checks if a value is a `LinearPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `LinearPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isLinearPath2d: (p: unknown) => p is LinearPath2d;
+declare const append$1: {
+  /**
+   * Appends a linear curve to a linear path.
+   *
+   * @param c - The linear curve to append.
+   * @returns A function that takes a linear path and returns a new linear path.
+   * @since 1.0.0
+   */
+  (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d;
+  /**
+   * Appends a linear curve to a linear path.
+   *
+   * @param p - The linear path to append to.
+   * @param c - The linear curve to append.
+   * @returns A new `LinearPath2d` instance with the appended curve.
+   * @since 1.0.0
+   */
+  (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
+};
+/**
+ * Calculates the length of a linear path.
+ *
+ * @param p - The linear path to calculate the length of.
+ * @returns The length of the linear path.
+ * @since 1.0.0
+ */
+declare const length$1: (p: LinearPath2d) => number;
+declare const solve$1: {
+  /**
+   * Solves a linear path for a given parameter.
+   *
+   * @param u - The parameter to solve for.
+   * @returns A function that takes a linear path and returns the solved point.
+   * @since 1.0.0
+   */
+  (u: number): (p: LinearPath2d) => Vector2;
+  /**
+   * Solves a linear path for a given parameter.
+   *
+   * @param p - The linear path to solve.
+   * @param u - The parameter to solve for.
+   * @returns The solved point on the linear path.
+   * @since 1.0.0
+   */
+  (p: LinearPath2d, u: number): Vector2;
+};
+/**
+ * Serializes a linear path as an SVG path data string (the value of a `<path>`
+ * element's `d` attribute), using `M` and `L` commands. Discontinuities between
+ * curves emit a fresh `M` command.
+ *
+ * @param p - The linear path to serialize.
+ * @returns The SVG path data string.
+ * @since 2.0.0
+ */
+declare const toPathData$1: (p: LinearPath2d) => string;
+/**
+ * Type-narrowing predicate: refines `LinearPath2d<T>` to
+ * `LinearPath2d<T & Continuous>` when adjacent curves connect at their join
+ * points.
+ *
+ * @param p - The linear path to check.
+ * @returns `true` when the path is continuous (G⁰).
+ * @since 2.0.0
+ */
+declare const isContinuous$1: <T>(p: LinearPath2d<T>) => p is LinearPath2d<T & Continuous>;
+/**
+ * Asserts that the linear path is continuous, throwing on failure.
+ *
+ * @param p - The linear path to assert against.
+ * @returns The same path, typed with the `Continuous` brand.
+ * @throws When the path has a discontinuity between adjacent curves.
+ * @since 2.0.0
+ */
+declare const asContinuous$1: <T>(p: LinearPath2d<T>) => LinearPath2d<T & Continuous>;
+//#endregion
+//#region src/path/quadratic2d.internal.d.ts
+declare const QuadraticPath2dTypeId: unique symbol;
+type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId;
+declare namespace quadratic2d_d_exports {
+  export { Continuous, QuadraticPath2d, append, asContinuous, fromArray, isContinuous, isQuadraticPath2d, length, make, solve, toPathData };
+}
+/**
+ * A quadratic path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Trait` type parameter accumulates trait brands as the path is refined
+ * via `isContinuous` / `asContinuous`.
+ *
+ * @since 1.0.0
+ */
+interface QuadraticPath2d<out Trait = unknown> extends Pipeable, Iterable<QuadraticCurve2d> {
+  readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId;
+  readonly [PathTraits]: Trait;
+}
+/**
+ * Creates a new `QuadraticPath2d` instance from a sequence of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `QuadraticPath2d` instance.
+ * @since 2.0.0
+ */
+declare const make: (...curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+/**
+ * Creates a new `QuadraticPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `QuadraticPath2d` instance.
+ * @since 2.0.0
+ */
+declare const fromArray: (curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+/**
+ * Checks if a value is a `QuadraticPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `QuadraticPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isQuadraticPath2d: (p: unknown) => p is QuadraticPath2d;
+declare const append: {
+  /**
+   * Appends a quadratic curve to a quadratic path.
+   *
+   * @param c - The quadratic curve to append.
+   * @returns A function that takes a quadratic path and returns a new quadratic path.
+   * @since 1.0.0
+   */
+  (c: QuadraticCurve2d): (p: QuadraticPath2d) => QuadraticPath2d;
+  /**
+   * Appends a quadratic curve to a quadratic path.
+   *
+   * @param p - The quadratic path to append to.
+   * @param c - The quadratic curve to append.
+   * @returns A new `QuadraticPath2d` instance with the appended curve.
+   * @since 1.0.0
+   */
+  (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d;
+};
+/**
+ * Calculates the length of a quadratic path.
+ *
+ * @param p - The quadratic path to calculate the length of.
+ * @returns The length of the path.
+ */
+declare const length: (p: QuadraticPath2d) => number;
+declare const solve: {
+  /**
+   * Solves a quadratic path at a given parameter.
+   *
+   * @param u - The parameter to solve for.
+   * @returns A function that takes a quadratic path and returns the solved point.
+   * @since 1.0.0
+   */
+  (u: number): (p: QuadraticPath2d) => Vector2;
+  /**
+   * Solves a quadratic path at a given parameter.
+   *
+   * @param p - The quadratic path to solve.
+   * @param u - The parameter to solve for.
+   * @returns The solved point.
+   * @since 1.0.0
+   */
+  (p: QuadraticPath2d, u: number): Vector2;
+};
+/**
+ * Serializes a quadratic path as an SVG path data string (the value of a
+ * `<path>` element's `d` attribute), using `M` and `Q` commands. Discontinuities
+ * between curves emit a fresh `M` command.
+ *
+ * @param p - The quadratic path to serialize.
+ * @returns The SVG path data string.
+ * @since 2.0.0
+ */
+declare const toPathData: (p: QuadraticPath2d) => string;
+/**
+ * Type-narrowing predicate: refines `QuadraticPath2d<T>` to
+ * `QuadraticPath2d<T & Continuous>` when adjacent curves connect.
+ *
+ * @since 2.0.0
+ */
+declare const isContinuous: <T>(p: QuadraticPath2d<T>) => p is QuadraticPath2d<T & Continuous>;
+/**
+ * Asserts that the quadratic path is continuous, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asContinuous: <T>(p: QuadraticPath2d<T>) => QuadraticPath2d<T & Continuous>;
+//#endregion
+export { cubic2d_d_exports as CubicPath2d, linear2d_d_exports as LinearPath2d, quadratic2d_d_exports as QuadraticPath2d, rationalCubic2d_d_exports as RationalCubicPath2d };
+//# sourceMappingURL=index.d.mts.map