@duplojs/utils 1.4.32 → 1.4.33

package/dist/number/acos.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/acos/index.md}
+ */
 function acos(value) {
     return Math.acos(value);
 }

package/dist/number/acos.d.ts

@@ -1 +1,28 @@
+/**
+ * Returns the arccosine (in radians) of a number.
+ * 
+ * Signature: `acos(value)` → returns a number
+ * 
+ * ```ts
+ * N.acos(1); // 0
+ * 
+ * pipe(
+ * 	1,
+ * 	N.acos,
+ * ); // 0
+ * 
+ * N.acos(0); // ~1.571
+ * 
+ * N.acos(-1); // ~3.142
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.acos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/acos
+ * 
+ * @namespace N
+ * 
+ */
 export declare function acos<GenericValue extends number>(value: GenericValue): number;

package/dist/number/acos.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include number/acos/index.md}
+ */
 function acos(value) {
     return Math.acos(value);
 }

package/dist/number/add.d.ts

@@ -1,2 +1,26 @@
+/**
+ * Adds two numbers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `add(value, operand)` → returns a number
+ * - Curried: `add(operand)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.add(10, 5); // 15
+ * 
+ * pipe(
+ * 	10,
+ * 	N.add(5),
+ * ); // 15
+ * 
+ * N.add(-3, 8); // 5
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/add
+ * 
+ * @namespace N
+ * 
+ */
 export declare function add<GenericValue extends number>(operand: number): (value: GenericValue) => number;
 export declare function add<GenericValue extends number>(value: GenericValue, operand: number): number;

package/dist/number/asin.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/asin/index.md}
+ */
 function asin(value) {
     return Math.asin(value);
 }

package/dist/number/asin.d.ts

@@ -1 +1,28 @@
+/**
+ * Returns the arcsine (in radians) of a number.
+ * 
+ * Signature: `asin(value)` → returns a number
+ * 
+ * ```ts
+ * N.asin(0); // 0
+ * 
+ * pipe(
+ * 	0,
+ * 	N.asin,
+ * ); // 0
+ * 
+ * N.asin(1); // ~1.571
+ * 
+ * N.asin(-1); // ~-1.571
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.asin`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/asin
+ * 
+ * @namespace N
+ * 
+ */
 export declare function asin<GenericValue extends number>(value: GenericValue): number;

package/dist/number/asin.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include number/asin/index.md}
+ */
 function asin(value) {
     return Math.asin(value);
 }

package/dist/number/atan.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/atan/index.md}
+ */
 function atan(value) {
     return Math.atan(value);
 }

package/dist/number/atan.d.ts

@@ -1 +1,28 @@
+/**
+ * Returns the arctangent (in radians) of a number.
+ * 
+ * Signature: `atan(value)` → returns a number
+ * 
+ * ```ts
+ * N.atan(0); // 0
+ * 
+ * pipe(
+ * 	0,
+ * 	N.atan,
+ * ); // 0
+ * 
+ * N.atan(1); // ~0.785
+ * 
+ * N.atan(-1); // ~-0.785
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.atan`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/atan
+ * 
+ * @namespace N
+ * 
+ */
 export declare function atan<GenericValue extends number>(value: GenericValue): number;

package/dist/number/atan.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include number/atan/index.md}
+ */
 function atan(value) {
     return Math.atan(value);
 }

package/dist/number/atan2.d.ts

@@ -1,2 +1,5 @@
+/**
+ * {@include number/atan2/index.md}
+ */
 export declare function atan2<GenericAxisY extends number>(axisX: number): (axisY: GenericAxisY) => number;
 export declare function atan2<GenericAxisY extends number>(axisY: GenericAxisY, axisX: number): number;

package/dist/number/between.d.ts

@@ -1,2 +1,35 @@
+/**
+ * Checks if a number is within a range (inclusive).
+ * 
+ * **Supported call styles:**
+ * - Classic: `between(value, greater, less)` → returns a boolean
+ * - Curried: `between(greater, less)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.between(
+ * 	5,
+ * 	0,
+ * 	10,
+ * ); // true
+ * 
+ * pipe(
+ * 	10,
+ * 	N.between(0, 10),
+ * ); // true
+ * 
+ * N.between(
+ * 	11,
+ * 	0,
+ * 	10,
+ * ); // false
+ * 
+ * ```
+ * 
+ * @see [`N.betweenThan`](https://utils.duplojs.dev/en/v1/api/number/betweenThan) For strict bounds
+ * @see https://utils.duplojs.dev/en/v1/api/number/between
+ * 
+ * @namespace N
+ * 
+ */
 export declare function between<GenericInput extends number>(greater: number, less: number): (input: GenericInput) => boolean;
 export declare function between<GenericInput extends number>(input: GenericInput, greater: number, less: number): boolean;

package/dist/number/betweenThan.d.ts

@@ -1,2 +1,35 @@
+/**
+ * Checks if a number is within a range (exclusive).
+ * 
+ * **Supported call styles:**
+ * - Classic: `betweenThan(value, greaterThan, lessThan)` → returns a boolean
+ * - Curried: `betweenThan(greaterThan, lessThan)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.betweenThan(
+ * 	5,
+ * 	0,
+ * 	10,
+ * ); // true
+ * 
+ * pipe(
+ * 	10,
+ * 	N.betweenThan(0, 10),
+ * ); // false
+ * 
+ * N.betweenThan(
+ * 	11,
+ * 	0,
+ * 	10,
+ * ); // false
+ * 
+ * ```
+ * 
+ * @see [`N.between`](https://utils.duplojs.dev/en/v1/api/number/between) For inclusive bounds
+ * @see https://utils.duplojs.dev/en/v1/api/number/betweenThan
+ * 
+ * @namespace N
+ * 
+ */
 export declare function betweenThan<GenericInput extends number>(greaterThan: number, lessThan: number): (input: GenericInput) => boolean;
 export declare function betweenThan<GenericInput extends number>(input: GenericInput, greaterThan: number, lessThan: number): boolean;

package/dist/number/ceil.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/ceil/index.md}
+ */
 function ceil(value) {
     return Math.ceil(value);
 }

package/dist/number/ceil.d.ts

@@ -1 +1,28 @@
+/**
+ * Rounds a number up to the next integer.
+ * 
+ * Signature: `ceil(value)` → returns a number
+ * 
+ * ```ts
+ * N.ceil(1.2); // 2
+ * 
+ * pipe(
+ * 	1.2,
+ * 	N.ceil,
+ * ); // 2
+ * 
+ * N.ceil(2.0); // 2
+ * 
+ * N.ceil(-1.2); // -1
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.ceil`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/ceil
+ * 
+ * @namespace N
+ * 
+ */
 export declare function ceil<GenericValue extends number>(value: GenericValue): number;

package/dist/number/ceil.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include number/ceil/index.md}
+ */
 function ceil(value) {
     return Math.ceil(value);
 }

package/dist/number/clamp.d.ts

@@ -1,2 +1,34 @@
+/**
+ * Clamps a number between a lower and upper bound.
+ * 
+ * **Supported call styles:**
+ * - Classic: `clamp(value, lowerBound, upperBound)` → returns a number
+ * - Curried: `clamp(lowerBound, upperBound)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.clamp(
+ * 	5,
+ * 	0,
+ * 	10,
+ * ); // 5
+ * 
+ * pipe(
+ * 	20,
+ * 	N.clamp(0, 10),
+ * ); // 10
+ * 
+ * N.clamp(
+ * 	-5,
+ * 	0,
+ * 	10,
+ * ); // 0
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/clamp
+ * 
+ * @namespace N
+ * 
+ */
 export declare function clamp<GenericValue extends number>(lowerBound: number, upperBound: number): (value: GenericValue) => number;
 export declare function clamp<GenericValue extends number>(value: GenericValue, lowerBound: number, upperBound: number): number;

package/dist/number/cos.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/cos/index.md}
+ */
 function cos(value) {
     return Math.cos(value);
 }

package/dist/number/cos.d.ts

@@ -1 +1,28 @@
+/**
+ * Returns the cosine of a number (in radians).
+ * 
+ * Signature: `cos(value)` → returns a number
+ * 
+ * ```ts
+ * N.cos(0); // 1
+ * 
+ * pipe(
+ * 	0,
+ * 	N.cos,
+ * ); // 1
+ * 
+ * N.cos(Math.PI / 2); // ~0
+ * 
+ * N.cos(Math.PI); // -1
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.cos`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/cos
+ * 
+ * @namespace N
+ * 
+ */
 export declare function cos<GenericValue extends number>(value: GenericValue): number;

package/dist/number/cos.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include number/cos/index.md}
+ */
 function cos(value) {
     return Math.cos(value);
 }

package/dist/number/divide.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Divides a number by another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `divide(value, operand)` → returns a number
+ * - Curried: `divide(operand)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.divide(
+ * 	10,
+ * 	2,
+ * ); // 5
+ * 
+ * pipe(
+ * 	9,
+ * 	N.divide(3),
+ * ); // 3
+ * 
+ * N.divide(
+ * 	5,
+ * 	2,
+ * ); // 2.5
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/divide
+ * 
+ * @namespace N
+ * 
+ */
 export declare function divide<GenericValue extends number>(divisor: number): (value: GenericValue) => number;
 export declare function divide<GenericValue extends number>(value: GenericValue, divisor: number): number;

package/dist/number/floor.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/floor/index.md}
+ */
 function floor(value) {
     return Math.floor(value);
 }

package/dist/number/floor.d.ts

@@ -1 +1,28 @@
+/**
+ * Rounds a number down to the previous integer.
+ * 
+ * Signature: `floor(value)` → returns a number
+ * 
+ * ```ts
+ * N.floor(1.9); // 1
+ * 
+ * pipe(
+ * 	1.9,
+ * 	N.floor,
+ * ); // 1
+ * 
+ * N.floor(2.0); // 2
+ * 
+ * N.floor(-1.2); // -2
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.floor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/floor
+ * 
+ * @namespace N
+ * 
+ */
 export declare function floor<GenericValue extends number>(value: GenericValue): number;

package/dist/number/floor.mjs

@@ -1,3 +1,6 @@
+/**
+ * {@include number/floor/index.md}
+ */
 function floor(value) {
     return Math.floor(value);
 }

package/dist/number/greater.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Checks if a value is greater than or equal to a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greater(value, threshold)` → returns a boolean
+ * - Curried: `greater(threshold)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.greater(
+ * 	10,
+ * 	10,
+ * ); // true
+ * 
+ * pipe(
+ * 	9,
+ * 	N.greater(10),
+ * ); // false
+ * 
+ * N.greater(
+ * 	9,
+ * 	10,
+ * ); // true
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/greater
+ * 
+ * @namespace N
+ * 
+ */
 export declare function greater<GenericValue extends number>(threshold: number): (value: GenericValue) => boolean;
 export declare function greater<GenericValue extends number>(value: GenericValue, threshold: number): boolean;

package/dist/number/greaterThan.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Checks if a value is strictly greater than a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greaterThan(value, threshold)` → returns a boolean
+ * - Curried: `greaterThan(threshold)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.greaterThan(
+ * 	10,
+ * 	10,
+ * ); // false
+ * 
+ * pipe(
+ * 	11,
+ * 	N.greaterThan(10),
+ * ); // true
+ * 
+ * N.greaterThan(
+ * 	9,
+ * 	10,
+ * ); // false
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/greaterThan
+ * 
+ * @namespace N
+ * 
+ */
 export declare function greaterThan<GenericValue extends number>(threshold: number): (value: GenericValue) => boolean;
 export declare function greaterThan<GenericValue extends number>(value: GenericValue, threshold: number): boolean;

package/dist/number/index.cjs

@@ -32,7 +32,9 @@ var between = require('./between.cjs');
 var betweenThan = require('./betweenThan.cjs');
 var sort = require('./sort.cjs');
 
-
+/**
+ * {@include number/index.md}
+ */
 
 exports.abs = abs.abs;
 exports.acos = acos.acos;

package/dist/number/index.d.ts

@@ -1,3 +1,28 @@
+/**
+ * Number utilities for immutable, type-safe numeric operations. Functions are designed
+ * for functional composition and do not mutate inputs.
+ * 
+ * **How to import:**
+ * - From the main entry (namespace style)
+ * - Via direct import for tree-shaking
+ * 
+ * ```ts
+ * import { DNumber, N } from "@duplojs/utils";
+ * import * as DNumber from "@duplojs/utils/number";
+ * import * as N from "@duplojs/utils/number";
+ * ```
+ * 
+ * What you will find in this namespace:
+ * - arithmetic (`N.add`, `N.subtract`, `N.multiply`, `N.divide`)
+ * - comparisons (`N.greater`, `N.less`, `N.between`)
+ * - rounding (`N.floor`, `N.ceil`, `N.round`, `N.trunc`)
+ * - math utilities (`N.min`, `N.max`, `N.sqrt`, `N.power`)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number
+ * 
+ * @namespace N
+ * 
+ */
 export * from "./abs";
 export * from "./acos";
 export * from "./add";

package/dist/number/index.mjs

@@ -29,3 +29,7 @@ export { sqrt } from './sqrt.mjs';
 export { between } from './between.mjs';
 export { betweenThan } from './betweenThan.mjs';
 export { sort } from './sort.mjs';
+
+/**
+ * {@include number/index.md}
+ */

package/dist/number/less.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Checks if a value is less than or equal to a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `less(value, threshold)` → returns a boolean
+ * - Curried: `less(threshold)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.less(
+ * 	10,
+ * 	10,
+ * ); // true
+ * 
+ * pipe(
+ * 	9,
+ * 	N.less(10),
+ * ); // true
+ * 
+ * N.less(
+ * 	11,
+ * 	10,
+ * ); // false
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/less
+ * 
+ * @namespace N
+ * 
+ */
 export declare function less<GenericValue extends number>(threshold: number): (value: GenericValue) => boolean;
 export declare function less<GenericValue extends number>(value: GenericValue, threshold: number): boolean;

package/dist/number/lessThan.d.ts

@@ -1,2 +1,32 @@
+/**
+ * Checks if a value is strictly less than a threshold.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lessThan(value, threshold)` → returns a boolean
+ * - Curried: `lessThan(threshold)` → returns a function waiting for the value
+ * 
+ * ```ts
+ * N.lessThan(
+ * 	10,
+ * 	10,
+ * ); // false
+ * 
+ * pipe(
+ * 	9,
+ * 	N.lessThan(10),
+ * ); // true
+ * 
+ * N.lessThan(
+ * 	11,
+ * 	10,
+ * ); // false
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/number/lessThan
+ * 
+ * @namespace N
+ * 
+ */
 export declare function lessThan<GenericValue extends number>(threshold: number): (value: GenericValue) => boolean;
 export declare function lessThan<GenericValue extends number>(value: GenericValue, threshold: number): boolean;

package/dist/number/max.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * {@include number/max/index.md}
+ */
 function max(input) {
     return Math.max(...input);
 }

package/dist/number/max.d.ts

@@ -1,2 +1,28 @@
 import { type AnyTuple } from "../common";
+/**
+ * Returns the largest value in a number tuple.
+ * 
+ * Signature: `max(tuple)` → returns a number
+ * 
+ * ```ts
+ * N.max([1, 5, 2]); // 5
+ * 
+ * pipe(
+ * 	<const>[-1, -3],
+ * 	N.max,
+ * ); // -1
+ * 
+ * N.max([0]); // 0
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Uses the same semantics as [`Math.max`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max)
+ * 
+ * @see [`N.min`](https://utils.duplojs.dev/en/v1/api/number/min) For the minimum value
+ * @see https://utils.duplojs.dev/en/v1/api/number/max
+ * 
+ * @namespace N
+ * 
+ */
 export declare function max<GenericInput extends AnyTuple<number>>(input: GenericInput): number;