@ts-fns/stdlib 0.1.0 → 0.2.1

package/dist/number/index.d.mts

@@ -1,43 +1,102 @@
 import { n as NaNError } from "../errors-CJsLpYo9.mjs";
 import { i as NarrowedTo } from "../types-D8f67ZCe.mjs";
-import { i as Order } from "../order.constants-BWSCg3C7.mjs";
+import { i as Order } from "../order.constants-DpGY-EDp.mjs";
 
 //#region src/number/_globalAliases.d.ts
+/**
+ * Number predicates from the global `Number` object: `isFinite`, `isInteger`, and `isSafeInteger`.
+ * @function
+ *
+ * @example
+ * ```ts
+ * isFinite(42); // true
+ * isInteger(3.14); // false
+ * isSafeInteger(Number.MAX_SAFE_INTEGER); // true
+ * ```
+ */
 declare const isFinite: (number: unknown) => boolean, isInteger: (number: unknown) => boolean, isSafeInteger: (number: unknown) => boolean;
-declare const numberConstructor: NumberConstructor;
+/**
+ * Alias of the built-in number constructor. `new Number() === new Number.Ctor()`
+ * @function
+ */
+declare const Ctor: NumberConstructor;
 //#endregion
 //#region src/number/add.d.ts
+/**
+ * Adds two numbers together.
+ *
+ * @example
+ * ```ts
+ * add(1, 2); // 3
+ * add(2)(1); // 3
+ * ```
+ */
 declare function add(right: number): (left: number) => number;
 declare function add(left: number, right: number): number;
 //#endregion
 //#region src/number/compare.d.ts
+/**
+ * Compares two numbers and returns their ordering.
+ *
+ * @example
+ * ```ts
+ * compare(1, 2); // -1
+ * compare(2, 2); // 0
+ * compare(3, 2); // 1
+ * ```
+ */
 declare function compare(left: number, right: number): Order;
 //#endregion
 //#region src/number/decrement.d.ts
+/**
+ * Returns the number decremented by one.
+ *
+ * @example
+ * ```ts
+ * decrement(5); // 4
+ * ```
+ */
 declare function decrement(num: number): number;
 //#endregion
 //#region src/number/divide.d.ts
+/**
+ * Divides one number by another.
+ *
+ * @example
+ * ```ts
+ * divide(10, 2); // 5
+ * divide(2)(10); // 5
+ * ```
+ */
 declare function divide(right: number): (left: number) => number;
 declare function divide(left: number, right: number): number;
 //#endregion
 //#region src/number/increment.d.ts
+/**
+ * Returns the number incremented by one.
+ *
+ * @example
+ * ```ts
+ * increment(5); // 6
+ * ```
+ */
 declare function increment(num: number): number;
 //#endregion
 //#region src/number/isNaN.d.ts
 /**
+ * Checks whether a number is `NaN`.
  *
- * @param num
- * @returns
+ * @example
+ * ```ts
+ * isNaN(NaN); // true
+ * isNaN(0); // false
+ * ```
  */
 declare function isNaN(num: number): boolean;
 //#endregion
 //#region src/number/isNil.d.ts
 /**
- * Check whether a value is nullish (`null` or `undefined`)
- *
- * @category Guard
- * @param value - The value to check.
- * @returns `true` if `value` is `null` or `undefined`; otherwise `false`.
+ * Checks whether a value is nullish (`null` or `undefined`).
  *
  * @example
  * ```ts
@@ -50,19 +109,19 @@ declare function isNil<T>(value: T): value is T & (null | undefined);
 //#endregion
 //#region src/number/isNotNaN.d.ts
 /**
+ * Checks whether a number is not `NaN`.
  *
- * @param num
- * @returns
+ * @example
+ * ```ts
+ * isNotNaN(0); // true
+ * isNotNaN(NaN); // false
+ * ```
  */
 declare function isNotNaN(num: number): boolean;
 //#endregion
 //#region src/number/isNumber.d.ts
 /**
- * Check whether a value is a number (primitive `number`, not `NaN`).
- *
- * @category Guard
- * @param data - The value to check.
- * @returns `true` if `data` is a number; otherwise `false`.
+ * Checks whether a value is a primitive `number`.
  *
  * @example
  * ```ts
@@ -75,38 +134,94 @@ declare function isNotNaN(num: number): boolean;
 declare function isNumber<T>(data: T | number): data is NarrowedTo<T, number>;
 //#endregion
 //#region src/number/multiply.d.ts
+/**
+ * Multiplies two numbers together.
+ *
+ * @example
+ * ```ts
+ * multiply(3, 4); // 12
+ * multiply(4)(3); // 12
+ * ```
+ */
 declare function multiply(right: number): (left: number) => number;
 declare function multiply(left: number, right: number): number;
 //#endregion
 //#region src/number/parseFloat.d.ts
 /**
+ * Parses a floating-point number from a string.
+ * Returns a NaN error when the input is not a valid number.
  *
+ * @example
+ * ```ts
+ * parseFloat('3.14'); // 3.14
+ * parseFloat('abc'); // NaNError
+ * ```
  */
 declare function parseFloat(data: string): NaNError | number;
 //#endregion
 //#region src/number/parseInt.d.ts
 /**
- * @throws {NanError}
+ * Parses a base-10 integer from a string.
+ * Returns a NaN error when the input is not a valid integer.
+ *
+ * @example
+ * ```ts
+ * parseInt('42'); // 42
+ * parseInt('abc'); // NaNError
+ * ```
  */
 declare function parseInt(data: string): NaNError | number;
 //#endregion
 //#region src/number/parseIntBase.d.ts
 /**
+ * Parses an integer from a string in the given radix.
+ * Throws a NaN error when the radix is invalid or parsing fails.
  *
- * @throws {NaNError}
+ * @example
+ * ```ts
+ * parseIntBase('ff', 16); // 255
+ * parseIntBase(16)('ff'); // 255
+ * ```
  */
 declare function parseIntBase(radix: number): (data: string) => number;
 declare function parseIntBase(data: string, radix: number): number;
 //#endregion
 //#region src/number/product.d.ts
+/**
+ * Multiplies all numbers in an array.
+ *
+ * @example
+ * ```ts
+ * product([2, 3, 4]); // 24
+ * product([]); // 1
+ * ```
+ */
 declare function product(data: number[]): number;
 //#endregion
 //#region src/number/subtract.d.ts
+/**
+ * Subtracts one number from another.
+ *
+ * @example
+ * ```ts
+ * subtract(10, 3); // 7
+ * subtract(3)(10); // 7
+ * ```
+ */
 declare function subtract(right: number): (left: number) => number;
 declare function subtract(left: number, right: number): number;
 //#endregion
 //#region src/number/sum.d.ts
+/**
+ * Sums all numbers in an array.
+ *
+ * @example
+ * ```ts
+ * sum([1, 2, 3]); // 6
+ * sum([]); // 0
+ * ```
+ */
 declare function sum(data: number[]): number;
 //#endregion
-export { numberConstructor as Number, add, compare, decrement, divide, increment, isFinite, isInteger, isNaN, isNil, isNotNaN, isNumber, isSafeInteger, multiply, parseFloat, parseInt, parseIntBase, product, subtract, sum };
+export { Ctor, add, compare, decrement, divide, increment, isFinite, isInteger, isNaN, isNil, isNotNaN, isNumber, isSafeInteger, multiply, parseFloat, parseInt, parseIntBase, product, subtract, sum };
 //# sourceMappingURL=index.d.mts.map

package/dist/number/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/number/_globalAliases.ts","../../src/number/add.ts","../../src/number/compare.ts","../../src/number/decrement.ts","../../src/number/divide.ts","../../src/number/increment.ts","../../src/number/isNaN.ts","../../src/number/isNil.ts","../../src/number/isNotNaN.ts","../../src/number/isNumber.ts","../../src/number/multiply.ts","../../src/number/parseFloat.ts","../../src/number/parseInt.ts","../../src/number/parseIntBase.ts","../../src/number/product.ts","../../src/number/subtract.ts","../../src/number/sum.ts"],"mappings":";;;;;cAAe,QAAA,GAAQ,MAAA,mCAAW,MAAA,uCAAe,MAAA;AAAA,cAE3C,iBAAA,EAAiB,iBAAS;;;iBCIhB,GAAA,CAAI,KAAA,YAAiB,IAAY;AAAA,iBACjC,GAAA,CAAI,IAAA,UAAc,KAAa;;;iBCJ/B,OAAA,CAAQ,IAAA,UAAc,KAAA,WAAgB,KAAK;;;iBCH3C,SAAA,CAAU,GAAW;;;iBCMrB,MAAA,CAAO,KAAA,YAAiB,IAAY;AAAA,iBACpC,MAAA,CAAO,IAAA,UAAc,KAAa;;;iBCPlC,SAAA,CAAU,GAAW;;;;;;;;iBCKrB,KAAA,CAAM,GAAW;;;;;;;;ANLjC;;;;;;;;AAAiD;iBOcjC,KAAA,IAAS,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC;;;;;;;;iBCT9B,QAAA,CAAS,GAAW;;;;;;;ARLpC;;;;;;;;AAAiD;;;iBSiBjC,QAAA,IAAY,IAAA,EAAM,CAAA,YAAa,IAAA,IAAQ,UAAA,CAAW,CAAA;;;iBCXlD,QAAA,CAAS,KAAA,YAAiB,IAAY;AAAA,iBACtC,QAAA,CAAS,IAAA,UAAc,KAAa;;;;;;iBCFpC,UAAA,CAAW,IAAA,WAAe,QAAQ;;;;;;iBCAlC,QAAA,CAAS,IAAA,WAAe,QAAQ;;;;;;;iBCgBhC,YAAA,CAAa,KAAA,YAAiB,IAAY;AAAA,iBAC1C,YAAA,CAAa,IAAA,UAAc,KAAa;;;iBCtBxC,OAAA,CAAQ,IAAc;;;iBCMtB,QAAA,CAAS,KAAA,YAAiB,IAAY;AAAA,iBACtC,QAAA,CAAS,IAAA,UAAc,KAAa;;;iBCPpC,GAAA,CAAI,IAAc"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/number/_globalAliases.ts","../../src/number/add.ts","../../src/number/compare.ts","../../src/number/decrement.ts","../../src/number/divide.ts","../../src/number/increment.ts","../../src/number/isNaN.ts","../../src/number/isNil.ts","../../src/number/isNotNaN.ts","../../src/number/isNumber.ts","../../src/number/multiply.ts","../../src/number/parseFloat.ts","../../src/number/parseInt.ts","../../src/number/parseIntBase.ts","../../src/number/product.ts","../../src/number/subtract.ts","../../src/number/sum.ts"],"mappings":";;;;;;;;;;AAWA;;;;;;cAAe,QAAA,GAAQ,MAAA,mCAAW,MAAA,uCAAe,MAAA;;AAAA;;;cAMpC,IAAA,EAAI,iBAAS;;;;;;;;AAN1B;;;;iBCIgB,GAAA,CAAI,KAAA,YAAiB,IAAY;AAAA,iBACjC,GAAA,CAAI,IAAA,UAAc,KAAa;;;;;;;ADL/C;;;;;;iBEEgB,OAAA,CAAQ,IAAA,UAAc,KAAA,WAAgB,KAAK;;;;;;;;AFF3D;;;iBGHgB,SAAA,CAAU,GAAW;;;;;;;;AHGrC;;;;iBIIgB,MAAA,CAAO,KAAA,YAAiB,IAAY;AAAA,iBACpC,MAAA,CAAO,IAAA,UAAc,KAAa;;;;;;;;AJLlD;;;iBKHgB,SAAA,CAAU,GAAW;;;;;;;;ALGrC;;;;iBMFgB,KAAA,CAAM,GAAW;;;;;;;;ANEjC;;;;;iBODgB,KAAA,IAAS,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAC;;;;;;;;APC9C;;;;iBQFgB,QAAA,CAAS,GAAW;;;;;;;AREpC;;;;;;;iBSEgB,QAAA,IAAY,IAAA,EAAM,CAAA,YAAa,IAAA,IAAQ,UAAA,CAAW,CAAA;;;;;;;;ATFlE;;;;iBUIgB,QAAA,CAAS,KAAA,YAAiB,IAAY;AAAA,iBACtC,QAAA,CAAS,IAAA,UAAc,KAAa;;;;;;;AVLpD;;;;;;iBWCgB,UAAA,CAAW,IAAA,WAAe,QAAQ;;;;;;;AXDlD;;;;;;iBYCgB,QAAA,CAAS,IAAA,WAAe,QAAQ;;;;;;;;AZDhD;;;;;iBagBgB,YAAA,CAAa,KAAA,YAAiB,IAAY;AAAA,iBAC1C,YAAA,CAAa,IAAA,UAAc,KAAa;;;;;;;;AbjBxD;;;;iBcFgB,OAAA,CAAQ,IAAc;;;;;;;;AdEtC;;;;iBeIgB,QAAA,CAAS,KAAA,YAAiB,IAAY;AAAA,iBACtC,QAAA,CAAS,IAAA,UAAc,KAAa;;;;;;;;AfLpD;;;;iBgBFgB,GAAA,CAAI,IAAc"}

package/dist/number/index.mjs

@@ -1,9 +1,24 @@
-import { t as purry } from "../purry-BOWmqwDB.mjs";
+import { t as purry } from "../purry-DXnhXie9.mjs";
 import { n as NaNError } from "../errors-Dw1kitu_.mjs";
 import "../order/index.mjs";
 //#region src/number/_globalAliases.ts
+/**
+* Number predicates from the global `Number` object: `isFinite`, `isInteger`, and `isSafeInteger`.
+* @function
+*
+* @example
+* ```ts
+* isFinite(42); // true
+* isInteger(3.14); // false
+* isSafeInteger(Number.MAX_SAFE_INTEGER); // true
+* ```
+*/
 const { isFinite, isInteger, isSafeInteger } = Number;
-const numberConstructor = Number;
+/**
+* Alias of the built-in number constructor. `new Number() === new Number.Ctor()`
+* @function
+*/
+const Ctor = Number;
 //#endregion
 //#region src/number/add.ts
 function addImplementation(left, right) {
@@ -14,6 +29,16 @@ function add(...args) {
 }
 //#endregion
 //#region src/number/compare.ts
+/**
+* Compares two numbers and returns their ordering.
+*
+* @example
+* ```ts
+* compare(1, 2); // -1
+* compare(2, 2); // 0
+* compare(3, 2); // 1
+* ```
+*/
 function compare(left, right) {
 	if (left < right) return -1;
 	if (left > right) return 1;
@@ -21,6 +46,14 @@ function compare(left, right) {
 }
 //#endregion
 //#region src/number/decrement.ts
+/**
+* Returns the number decremented by one.
+*
+* @example
+* ```ts
+* decrement(5); // 4
+* ```
+*/
 function decrement(num) {
 	return num - 1;
 }
@@ -34,15 +67,27 @@ function divide(...args) {
 }
 //#endregion
 //#region src/number/increment.ts
+/**
+* Returns the number incremented by one.
+*
+* @example
+* ```ts
+* increment(5); // 6
+* ```
+*/
 function increment(num) {
 	return num + 1;
 }
 //#endregion
 //#region src/number/isNaN.ts
 /**
+* Checks whether a number is `NaN`.
 *
-* @param num
-* @returns
+* @example
+* ```ts
+* isNaN(NaN); // true
+* isNaN(0); // false
+* ```
 */
 function isNaN(num) {
 	return Number.isNaN(num);
@@ -50,11 +95,7 @@ function isNaN(num) {
 //#endregion
 //#region src/number/isNil.ts
 /**
-* Check whether a value is nullish (`null` or `undefined`)
-*
-* @category Guard
-* @param value - The value to check.
-* @returns `true` if `value` is `null` or `undefined`; otherwise `false`.
+* Checks whether a value is nullish (`null` or `undefined`).
 *
 * @example
 * ```ts
@@ -69,9 +110,13 @@ function isNil(value) {
 //#endregion
 //#region src/number/isNotNaN.ts
 /**
+* Checks whether a number is not `NaN`.
 *
-* @param num
-* @returns
+* @example
+* ```ts
+* isNotNaN(0); // true
+* isNotNaN(NaN); // false
+* ```
 */
 function isNotNaN(num) {
 	return !Number.isNaN(num);
@@ -79,11 +124,7 @@ function isNotNaN(num) {
 //#endregion
 //#region src/number/isNumber.ts
 /**
-* Check whether a value is a number (primitive `number`, not `NaN`).
-*
-* @category Guard
-* @param data - The value to check.
-* @returns `true` if `data` is a number; otherwise `false`.
+* Checks whether a value is a primitive `number`.
 *
 * @example
 * ```ts
@@ -107,7 +148,14 @@ function multiply(...args) {
 //#endregion
 //#region src/number/parseFloat.ts
 /**
+* Parses a floating-point number from a string.
+* Returns a NaN error when the input is not a valid number.
 *
+* @example
+* ```ts
+* parseFloat('3.14'); // 3.14
+* parseFloat('abc'); // NaNError
+* ```
 */
 function parseFloat(data) {
 	const num = Number.parseFloat(data);
@@ -117,7 +165,14 @@ function parseFloat(data) {
 //#endregion
 //#region src/number/parseInt.ts
 /**
-* @throws {NanError}
+* Parses a base-10 integer from a string.
+* Returns a NaN error when the input is not a valid integer.
+*
+* @example
+* ```ts
+* parseInt('42'); // 42
+* parseInt('abc'); // NaNError
+* ```
 */
 function parseInt(data) {
 	const num = Number.parseInt(data, 10);
@@ -137,6 +192,15 @@ function parseIntBase(...args) {
 }
 //#endregion
 //#region src/number/product.ts
+/**
+* Multiplies all numbers in an array.
+*
+* @example
+* ```ts
+* product([2, 3, 4]); // 24
+* product([]); // 1
+* ```
+*/
 function product(data) {
 	return data.reduce((a, b) => a * b, 1);
 }
@@ -150,10 +214,19 @@ function subtract(...args) {
 }
 //#endregion
 //#region src/number/sum.ts
+/**
+* Sums all numbers in an array.
+*
+* @example
+* ```ts
+* sum([1, 2, 3]); // 6
+* sum([]); // 0
+* ```
+*/
 function sum(data) {
 	return data.reduce((a, b) => a + b, 0);
 }
 //#endregion
-export { numberConstructor as Number, add, compare, decrement, divide, increment, isFinite, isInteger, isNaN, isNil, isNotNaN, isNumber, isSafeInteger, multiply, parseFloat, parseInt, parseIntBase, product, subtract, sum };
+export { Ctor, add, compare, decrement, divide, increment, isFinite, isInteger, isNaN, isNil, isNotNaN, isNumber, isSafeInteger, multiply, parseFloat, parseInt, parseIntBase, product, subtract, sum };
 
 //# sourceMappingURL=index.mjs.map

package/dist/number/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/number/_globalAliases.ts","../../src/number/add.ts","../../src/number/compare.ts","../../src/number/decrement.ts","../../src/number/divide.ts","../../src/number/increment.ts","../../src/number/isNaN.ts","../../src/number/isNil.ts","../../src/number/isNotNaN.ts","../../src/number/isNumber.ts","../../src/number/multiply.ts","../../src/number/parseFloat.ts","../../src/number/parseInt.ts","../../src/number/parseIntBase.ts","../../src/number/product.ts","../../src/number/subtract.ts","../../src/number/sum.ts"],"sourcesContent":["export const { isFinite, isInteger, isSafeInteger } = Number;\n\nconst numberConstructor = Number;\nexport { numberConstructor as Number };\n","import { purry } from '../function/purry';\n\nfunction addImplementation(left: number, right: number): number {\n  return left + right;\n}\n\nexport function add(right: number): (left: number) => number;\nexport function add(left: number, right: number): number;\nexport function add(...args: unknown[]): unknown {\n  return purry(addImplementation, args);\n}\n","import type { Order } from '../order';\nimport { eq, gt, lt } from '../order';\n\nexport function compare(left: number, right: number): Order {\n  if (left < right) return lt;\n  if (left > right) return gt;\n  return eq;\n}\n","export function decrement(num: number): number {\n  return num - 1;\n}\n","import { purry } from '../function/purry';\n\nfunction divideImplementation(left: number, right: number): number {\n  return left / right;\n}\n\nexport function divide(right: number): (left: number) => number;\nexport function divide(left: number, right: number): number;\nexport function divide(...args: unknown[]): unknown {\n  return purry(divideImplementation, args);\n}\n","export function increment(num: number): number {\n  return num + 1;\n}\n","/**\n *\n * @param num\n * @returns\n */\nexport function isNaN(num: number): boolean {\n  return Number.isNaN(num);\n}\n","/**\n * Check whether a value is nullish (`null` or `undefined`)\n *\n * @category Guard\n * @param value - The value to check.\n * @returns `true` if `value` is `null` or `undefined`; otherwise `false`.\n *\n * @example\n * ```ts\n * isNil(null); // true\n * isNil(undefined); // true\n * isNil(0); // false\n * ```\n */\nexport function isNil<T>(value: T): value is T & (null | undefined) {\n  return value == null;\n}\n","/**\n *\n * @param num\n * @returns\n */\nexport function isNotNaN(num: number): boolean {\n  return !Number.isNaN(num);\n}\n","import type { NarrowedTo } from '../types';\n\n/**\n * Check whether a value is a number (primitive `number`, not `NaN`).\n *\n * @category Guard\n * @param data - The value to check.\n * @returns `true` if `data` is a number; otherwise `false`.\n *\n * @example\n * ```ts\n * isNumber(1); // true\n * isNumber(Infinity); // true\n * isNumber(NaN); // true\n * isNumber('1'); // false\n * ```\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number';\n}\n","import { purry } from '../function/purry';\n\nfunction multiplyImplementation(left: number, right: number): number {\n  return left * right;\n}\n\nexport function multiply(right: number): (left: number) => number;\nexport function multiply(left: number, right: number): number;\nexport function multiply(...args: unknown[]): unknown {\n  return purry(multiplyImplementation, args);\n}\n","import { NaNError } from '../errors';\n\n/**\n *\n */\nexport function parseFloat(data: string): NaNError | number {\n  const num = Number.parseFloat(data);\n\n  if (Number.isNaN(num)) {\n    return new NaNError(`Num.parseFloat() :: \"${data}\" is NaN`);\n  }\n\n  return num;\n}\n","import { NaNError } from '../errors';\n\n/**\n * @throws {NanError}\n */\nexport function parseInt(data: string): NaNError | number {\n  const num = Number.parseInt(data, 10);\n\n  if (Number.isNaN(num)) {\n    return new NaNError(`Num.parseInt() :: \"${data}\" is NaN`);\n  }\n\n  return num;\n}\n","import { NaNError } from '../errors';\nimport { purry } from '../function/purry';\n\nfunction parseIntBaseImplementation(data: string, radix: number): number {\n  if (typeof radix !== 'number') {\n    throw new NaNError(`Num.parseFloat(_, radix) :: \"${data}\" must be number`);\n  }\n\n  const num = Number.parseInt(data, radix);\n\n  if (Number.isNaN(num)) {\n    throw new NaNError(`Num.parseFloat(data, _) :: \"${data}\" is NaN`);\n  }\n\n  return num;\n}\n\n/**\n *\n * @throws {NaNError}\n */\nexport function parseIntBase(radix: number): (data: string) => number;\nexport function parseIntBase(data: string, radix: number): number;\nexport function parseIntBase(...args: unknown[]): unknown {\n  return purry(parseIntBaseImplementation, args);\n}\n","export function product(data: number[]): number {\n  return data.reduce((a, b) => a * b, 1);\n}\n","import { purry } from '../function/purry';\n\nfunction subtractImplementation(left: number, right: number): number {\n  return left - right;\n}\n\nexport function subtract(right: number): (left: number) => number;\nexport function subtract(left: number, right: number): number;\nexport function subtract(...args: unknown[]): unknown {\n  return purry(subtractImplementation, args);\n}\n","export function sum(data: number[]): number {\n  return data.reduce((a, b) => a + b, 0);\n}\n"],"mappings":";;;;AAAA,MAAa,EAAE,UAAU,WAAW,kBAAkB;AAEtD,MAAM,oBAAoB;;;ACA1B,SAAS,kBAAkB,MAAc,OAAuB;CAC9D,OAAO,OAAO;AAChB;AAIA,SAAgB,IAAI,GAAG,MAA0B;CAC/C,OAAO,MAAM,mBAAmB,IAAI;AACtC;;;ACPA,SAAgB,QAAQ,MAAc,OAAsB;CAC1D,IAAI,OAAO,OAAO,OAAA;CAClB,IAAI,OAAO,OAAO,OAAA;CAClB,OAAA;AACF;;;ACPA,SAAgB,UAAU,KAAqB;CAC7C,OAAO,MAAM;AACf;;;ACAA,SAAS,qBAAqB,MAAc,OAAuB;CACjE,OAAO,OAAO;AAChB;AAIA,SAAgB,OAAO,GAAG,MAA0B;CAClD,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;ACVA,SAAgB,UAAU,KAAqB;CAC7C,OAAO,MAAM;AACf;;;;;;;;ACGA,SAAgB,MAAM,KAAsB;CAC1C,OAAO,OAAO,MAAM,GAAG;AACzB;;;;;;;;;;;;;;;;;ACOA,SAAgB,MAAS,OAA2C;CAClE,OAAO,SAAS;AAClB;;;;;;;;ACXA,SAAgB,SAAS,KAAsB;CAC7C,OAAO,CAAC,OAAO,MAAM,GAAG;AAC1B;;;;;;;;;;;;;;;;;;ACUA,SAAgB,SAAY,MAAiD;CAC3E,OAAO,OAAO,SAAS;AACzB;;;ACjBA,SAAS,uBAAuB,MAAc,OAAuB;CACnE,OAAO,OAAO;AAChB;AAIA,SAAgB,SAAS,GAAG,MAA0B;CACpD,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;;;;ACLA,SAAgB,WAAW,MAAiC;CAC1D,MAAM,MAAM,OAAO,WAAW,IAAI;CAElC,IAAI,OAAO,MAAM,GAAG,GAClB,OAAO,IAAI,SAAS,wBAAwB,KAAK,SAAS;CAG5D,OAAO;AACT;;;;;;ACRA,SAAgB,SAAS,MAAiC;CACxD,MAAM,MAAM,OAAO,SAAS,MAAM,EAAE;CAEpC,IAAI,OAAO,MAAM,GAAG,GAClB,OAAO,IAAI,SAAS,sBAAsB,KAAK,SAAS;CAG1D,OAAO;AACT;;;ACVA,SAAS,2BAA2B,MAAc,OAAuB;CACvE,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,SAAS,gCAAgC,KAAK,iBAAiB;CAG3E,MAAM,MAAM,OAAO,SAAS,MAAM,KAAK;CAEvC,IAAI,OAAO,MAAM,GAAG,GAClB,MAAM,IAAI,SAAS,+BAA+B,KAAK,SAAS;CAGlE,OAAO;AACT;AAQA,SAAgB,aAAa,GAAG,MAA0B;CACxD,OAAO,MAAM,4BAA4B,IAAI;AAC/C;;;ACzBA,SAAgB,QAAQ,MAAwB;CAC9C,OAAO,KAAK,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC;AACvC;;;ACAA,SAAS,uBAAuB,MAAc,OAAuB;CACnE,OAAO,OAAO;AAChB;AAIA,SAAgB,SAAS,GAAG,MAA0B;CACpD,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;ACVA,SAAgB,IAAI,MAAwB;CAC1C,OAAO,KAAK,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC;AACvC"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/number/_globalAliases.ts","../../src/number/add.ts","../../src/number/compare.ts","../../src/number/decrement.ts","../../src/number/divide.ts","../../src/number/increment.ts","../../src/number/isNaN.ts","../../src/number/isNil.ts","../../src/number/isNotNaN.ts","../../src/number/isNumber.ts","../../src/number/multiply.ts","../../src/number/parseFloat.ts","../../src/number/parseInt.ts","../../src/number/parseIntBase.ts","../../src/number/product.ts","../../src/number/subtract.ts","../../src/number/sum.ts"],"sourcesContent":["/**\n * Number predicates from the global `Number` object: `isFinite`, `isInteger`, and `isSafeInteger`.\n * @function\n *\n * @example\n * ```ts\n * isFinite(42); // true\n * isInteger(3.14); // false\n * isSafeInteger(Number.MAX_SAFE_INTEGER); // true\n * ```\n */\nexport const { isFinite, isInteger, isSafeInteger } = Number;\n\n/**\n * Alias of the built-in number constructor. `new Number() === new Number.Ctor()`\n * @function\n */\nexport const Ctor = Number;\n","import { purry } from '../function/purry';\n\nfunction addImplementation(left: number, right: number): number {\n  return left + right;\n}\n\n/**\n * Adds two numbers together.\n *\n * @example\n * ```ts\n * add(1, 2); // 3\n * add(2)(1); // 3\n * ```\n */\nexport function add(right: number): (left: number) => number;\nexport function add(left: number, right: number): number;\nexport function add(...args: unknown[]): unknown {\n  return purry(addImplementation, args);\n}\n","import type { Order } from '../order';\nimport { eq, gt, lt } from '../order';\n\n/**\n * Compares two numbers and returns their ordering.\n *\n * @example\n * ```ts\n * compare(1, 2); // -1\n * compare(2, 2); // 0\n * compare(3, 2); // 1\n * ```\n */\nexport function compare(left: number, right: number): Order {\n  if (left < right) return lt;\n  if (left > right) return gt;\n  return eq;\n}\n","/**\n * Returns the number decremented by one.\n *\n * @example\n * ```ts\n * decrement(5); // 4\n * ```\n */\nexport function decrement(num: number): number {\n  return num - 1;\n}\n","import { purry } from '../function/purry';\n\nfunction divideImplementation(left: number, right: number): number {\n  return left / right;\n}\n\n/**\n * Divides one number by another.\n *\n * @example\n * ```ts\n * divide(10, 2); // 5\n * divide(2)(10); // 5\n * ```\n */\nexport function divide(right: number): (left: number) => number;\nexport function divide(left: number, right: number): number;\nexport function divide(...args: unknown[]): unknown {\n  return purry(divideImplementation, args);\n}\n","/**\n * Returns the number incremented by one.\n *\n * @example\n * ```ts\n * increment(5); // 6\n * ```\n */\nexport function increment(num: number): number {\n  return num + 1;\n}\n","/**\n * Checks whether a number is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(NaN); // true\n * isNaN(0); // false\n * ```\n */\nexport function isNaN(num: number): boolean {\n  return Number.isNaN(num);\n}\n","/**\n * Checks whether a value is nullish (`null` or `undefined`).\n *\n * @example\n * ```ts\n * isNil(null); // true\n * isNil(undefined); // true\n * isNil(0); // false\n * ```\n */\nexport function isNil<T>(value: T): value is T & (null | undefined) {\n  return value == null;\n}\n","/**\n * Checks whether a number is not `NaN`.\n *\n * @example\n * ```ts\n * isNotNaN(0); // true\n * isNotNaN(NaN); // false\n * ```\n */\nexport function isNotNaN(num: number): boolean {\n  return !Number.isNaN(num);\n}\n","import type { NarrowedTo } from '../types';\n\n/**\n * Checks whether a value is a primitive `number`.\n *\n * @example\n * ```ts\n * isNumber(1); // true\n * isNumber(Infinity); // true\n * isNumber(NaN); // true\n * isNumber('1'); // false\n * ```\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number';\n}\n","import { purry } from '../function/purry';\n\nfunction multiplyImplementation(left: number, right: number): number {\n  return left * right;\n}\n\n/**\n * Multiplies two numbers together.\n *\n * @example\n * ```ts\n * multiply(3, 4); // 12\n * multiply(4)(3); // 12\n * ```\n */\nexport function multiply(right: number): (left: number) => number;\nexport function multiply(left: number, right: number): number;\nexport function multiply(...args: unknown[]): unknown {\n  return purry(multiplyImplementation, args);\n}\n","import { NaNError } from '../errors';\n\n/**\n * Parses a floating-point number from a string.\n * Returns a NaN error when the input is not a valid number.\n *\n * @example\n * ```ts\n * parseFloat('3.14'); // 3.14\n * parseFloat('abc'); // NaNError\n * ```\n */\nexport function parseFloat(data: string): NaNError | number {\n  const num = Number.parseFloat(data);\n\n  if (Number.isNaN(num)) {\n    return new NaNError(`Num.parseFloat() :: \"${data}\" is NaN`);\n  }\n\n  return num;\n}\n","import { NaNError } from '../errors';\n\n/**\n * Parses a base-10 integer from a string.\n * Returns a NaN error when the input is not a valid integer.\n *\n * @example\n * ```ts\n * parseInt('42'); // 42\n * parseInt('abc'); // NaNError\n * ```\n */\nexport function parseInt(data: string): NaNError | number {\n  const num = Number.parseInt(data, 10);\n\n  if (Number.isNaN(num)) {\n    return new NaNError(`Num.parseInt() :: \"${data}\" is NaN`);\n  }\n\n  return num;\n}\n","import { NaNError } from '../errors';\nimport { purry } from '../function/purry';\n\nfunction parseIntBaseImplementation(data: string, radix: number): number {\n  if (typeof radix !== 'number') {\n    throw new NaNError(`Num.parseFloat(_, radix) :: \"${data}\" must be number`);\n  }\n\n  const num = Number.parseInt(data, radix);\n\n  if (Number.isNaN(num)) {\n    throw new NaNError(`Num.parseFloat(data, _) :: \"${data}\" is NaN`);\n  }\n\n  return num;\n}\n\n/**\n * Parses an integer from a string in the given radix.\n * Throws a NaN error when the radix is invalid or parsing fails.\n *\n * @example\n * ```ts\n * parseIntBase('ff', 16); // 255\n * parseIntBase(16)('ff'); // 255\n * ```\n */\nexport function parseIntBase(radix: number): (data: string) => number;\nexport function parseIntBase(data: string, radix: number): number;\nexport function parseIntBase(...args: unknown[]): unknown {\n  return purry(parseIntBaseImplementation, args);\n}\n","/**\n * Multiplies all numbers in an array.\n *\n * @example\n * ```ts\n * product([2, 3, 4]); // 24\n * product([]); // 1\n * ```\n */\nexport function product(data: number[]): number {\n  return data.reduce((a, b) => a * b, 1);\n}\n","import { purry } from '../function/purry';\n\nfunction subtractImplementation(left: number, right: number): number {\n  return left - right;\n}\n\n/**\n * Subtracts one number from another.\n *\n * @example\n * ```ts\n * subtract(10, 3); // 7\n * subtract(3)(10); // 7\n * ```\n */\nexport function subtract(right: number): (left: number) => number;\nexport function subtract(left: number, right: number): number;\nexport function subtract(...args: unknown[]): unknown {\n  return purry(subtractImplementation, args);\n}\n","/**\n * Sums all numbers in an array.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]); // 6\n * sum([]); // 0\n * ```\n */\nexport function sum(data: number[]): number {\n  return data.reduce((a, b) => a + b, 0);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAWA,MAAa,EAAE,UAAU,WAAW,kBAAkB;;;;;AAMtD,MAAa,OAAO;;;ACfpB,SAAS,kBAAkB,MAAc,OAAuB;CAC9D,OAAO,OAAO;AAChB;AAaA,SAAgB,IAAI,GAAG,MAA0B;CAC/C,OAAO,MAAM,mBAAmB,IAAI;AACtC;;;;;;;;;;;;;ACNA,SAAgB,QAAQ,MAAc,OAAsB;CAC1D,IAAI,OAAO,OAAO,OAAA;CAClB,IAAI,OAAO,OAAO,OAAA;CAClB,OAAA;AACF;;;;;;;;;;;ACTA,SAAgB,UAAU,KAAqB;CAC7C,OAAO,MAAM;AACf;;;ACRA,SAAS,qBAAqB,MAAc,OAAuB;CACjE,OAAO,OAAO;AAChB;AAaA,SAAgB,OAAO,GAAG,MAA0B;CAClD,OAAO,MAAM,sBAAsB,IAAI;AACzC;;;;;;;;;;;ACXA,SAAgB,UAAU,KAAqB;CAC7C,OAAO,MAAM;AACf;;;;;;;;;;;;ACDA,SAAgB,MAAM,KAAsB;CAC1C,OAAO,OAAO,MAAM,GAAG;AACzB;;;;;;;;;;;;;ACDA,SAAgB,MAAS,OAA2C;CAClE,OAAO,SAAS;AAClB;;;;;;;;;;;;ACHA,SAAgB,SAAS,KAAsB;CAC7C,OAAO,CAAC,OAAO,MAAM,GAAG;AAC1B;;;;;;;;;;;;;;ACEA,SAAgB,SAAY,MAAiD;CAC3E,OAAO,OAAO,SAAS;AACzB;;;ACbA,SAAS,uBAAuB,MAAc,OAAuB;CACnE,OAAO,OAAO;AAChB;AAaA,SAAgB,SAAS,GAAG,MAA0B;CACpD,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;;;;;;;;;;;ACPA,SAAgB,WAAW,MAAiC;CAC1D,MAAM,MAAM,OAAO,WAAW,IAAI;CAElC,IAAI,OAAO,MAAM,GAAG,GAClB,OAAO,IAAI,SAAS,wBAAwB,KAAK,SAAS;CAG5D,OAAO;AACT;;;;;;;;;;;;;ACRA,SAAgB,SAAS,MAAiC;CACxD,MAAM,MAAM,OAAO,SAAS,MAAM,EAAE;CAEpC,IAAI,OAAO,MAAM,GAAG,GAClB,OAAO,IAAI,SAAS,sBAAsB,KAAK,SAAS;CAG1D,OAAO;AACT;;;ACjBA,SAAS,2BAA2B,MAAc,OAAuB;CACvE,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,SAAS,gCAAgC,KAAK,iBAAiB;CAG3E,MAAM,MAAM,OAAO,SAAS,MAAM,KAAK;CAEvC,IAAI,OAAO,MAAM,GAAG,GAClB,MAAM,IAAI,SAAS,+BAA+B,KAAK,SAAS;CAGlE,OAAO;AACT;AAcA,SAAgB,aAAa,GAAG,MAA0B;CACxD,OAAO,MAAM,4BAA4B,IAAI;AAC/C;;;;;;;;;;;;ACtBA,SAAgB,QAAQ,MAAwB;CAC9C,OAAO,KAAK,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC;AACvC;;;ACTA,SAAS,uBAAuB,MAAc,OAAuB;CACnE,OAAO,OAAO;AAChB;AAaA,SAAgB,SAAS,GAAG,MAA0B;CACpD,OAAO,MAAM,wBAAwB,IAAI;AAC3C;;;;;;;;;;;;ACVA,SAAgB,IAAI,MAAwB;CAC1C,OAAO,KAAK,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC;AACvC"}

package/dist/object/index.cjs

@@ -1,12 +1,64 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_purry = require("../purry-B2_0DGLV.cjs");
-require("../function-CB82a2GS.cjs");
-const require_get = require("../get-yrs1Kqho.cjs");
+require("../function-DYPifnmg.cjs");
+const require_purry = require("../purry-Dqp_F64t.cjs");
+const require_get = require("../get-1kqkxPFX.cjs");
 //#region src/object/_globalAliases.ts
-const { fromEntries, hasOwn, is, keys, values } = Object;
 /**
-* @category Object
+* Creates an object from an iterable of key-value pairs.
 * @function
+*
+* @example
+* ```ts
+* fromEntries([['a', 1], ['b', 2]]); // { a: 1, b: 2 }
+* ```
+*/
+const fromEntries = Object.fromEntries;
+/**
+* Checks whether an object has the specified property as its own property.
+* @function
+*
+* @example
+* ```ts
+* hasOwn({ a: 1 }, 'a'); // true
+* hasOwn({ a: 1 }, 'toString'); // false
+* ```
+*/
+const hasOwn = Object.hasOwn;
+/**
+* Determines whether two values are the same value.
+* @function
+*
+* @example
+* ```ts
+* is(NaN, NaN); // true
+* is(0, -0); // false
+* ```
+*/
+const is = Object.is;
+/**
+* Returns an array of an object's own enumerable string-keyed property names.
+* @function
+*
+* @example
+* ```ts
+* keys({ a: 1, b: 2 }); // ['a', 'b']
+* ```
+*/
+const keys = Object.keys;
+/**
+* Returns an array of an object's own enumerable property values.
+* @function
+*
+* @example
+* ```ts
+* values({ a: 1, b: 2 }); // [1, 2]
+* ```
+*/
+const values = Object.values;
+/**
+* Returns an array of an object's own enumerable string-keyed property key-value pairs.
+* @function
+*
 * @example
 * ```ts
 * entries({ a: 1, b: 2 }); // [['a', 1], ['b', 2]]
@@ -16,7 +68,12 @@ const entries = Object.entries;
 //#endregion
 //#region src/object/clone.ts
 /**
-* Alias of structuredClone without the optional second argument
+* Creates a deep clone of a value using `structuredClone`.
+*
+* @example
+* ```ts
+* clone({ a: 1, b: { c: 2 } }); // { a: 1, b: { c: 2 } }
+* ```
 */
 function clone(data) {
 	return globalThis.structuredClone(data);
@@ -103,8 +160,55 @@ function mergeLeftImplementation(left, right) {
 function mergeLeft(...args) {
 	return require_purry.purry(mergeLeftImplementation, args);
 }
+/**
+* Like `merge`, but gives precedence to properties from the left object.
+*
+* @example
+* ```ts
+* merge.left({ a: 1 }, { b: 2 }); // { a: 1, b: 2 }
+* merge.left({ b: 3 })({ a: 1, b: 2 }); // { a: 1, b: 3 }
+* ```
+*/
 merge.left = mergeLeft;
 //#endregion
+//#region src/object/mergeDeep.ts
+function isObjectType(data) {
+	return typeof data === "object" && data !== null;
+}
+function mergeDeepImplementation(left, right) {
+	const nextObj = {
+		...right,
+		...left
+	};
+	for (const key of Object.keys(left)) {
+		if (!Object.hasOwn(right, key)) continue;
+		const leftVal = left[key];
+		const rightVal = right[key];
+		if (isObjectType(leftVal) && isObjectType(rightVal) && !Array.isArray(leftVal) && !Array.isArray(rightVal)) nextObj[key] = mergeDeepImplementation(leftVal, rightVal);
+		else nextObj[key] = right[key];
+	}
+	return nextObj;
+}
+function mergeDeep(...args) {
+	return require_purry.purry(mergeDeepImplementation, args);
+}
+function mergeDeepLeftImplementation(left, right) {
+	return mergeDeepImplementation(right, left);
+}
+function mergeDeepLeft(...args) {
+	return require_purry.purry(mergeDeepLeftImplementation, args);
+}
+/**
+* Like `mergeDeep`, but gives precedence to properties from the left object.
+*
+* @example
+* ```ts
+* mergeDeep.left({ a: { x: 1 } }, { a: { y: 2 }, b: 3 }); // { a: { x: 1, y: 2 }, b: 3 }
+* mergeDeep.left({ b: 3 })({ a: { x: 1 }, b: { y: 2 } }); // { a: { x: 1 }, b: 3 }
+* ```
+*/
+mergeDeep.left = mergeDeepLeft;
+//#endregion
 //#region src/object/omit.ts
 function omitImplementation(data, keys) {
 	const keysSet = new Set(keys);
@@ -171,7 +275,6 @@ exports.evolve = evolve;
 exports.forEach = forEach;
 exports.fromEntries = fromEntries;
 exports.get = require_get.get;
-exports.getAssert = require_get.getAssert;
 exports.groupBy = groupBy;
 exports.hasOwn = hasOwn;
 exports.indexBy = indexBy;
@@ -179,6 +282,7 @@ exports.is = is;
 exports.keys = keys;
 exports.map = map;
 exports.merge = merge;
+exports.mergeDeep = mergeDeep;
 exports.mergeLeft = mergeLeft;
 exports.omit = omit;
 exports.pick = pick;