es-toolkit 1.0.3 → 1.0.4-dev.41

package/dist/object/omit.mjs

@@ -0,0 +1,8 @@
+import {
+  omit
+} from "../chunk-J6SWM4X6.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  omit
+};
+//# sourceMappingURL=omit.mjs.map

package/dist/object/omit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/object/omitBy.mjs → dist/object/omitBy.d.mts}

@@ -1,14 +1,12 @@
-import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
-
 /**
  * Creates a new object composed of the properties that do not satisfy the predicate function.
  *
- * This function takes an object and a predicate function, and returns a new object that 
+ * This function takes an object and a predicate function, and returns a new object that
  * includes only the properties for which the predicate function returns false.
  *
  * @param {T} obj - The object to omit properties from.
- * @param {(value: T[string], key: string) => boolean} shouldOmit - A predicate function that determines 
- * whether a property should be omitted. It takes the property's key and value as arguments and returns `true` 
+ * @param {(value: T[string], key: string) => boolean} shouldOmit - A predicate function that determines
+ * whether a property should be omitted. It takes the property's key and value as arguments and returns `true`
  * if the property should be omitted, and `false` otherwise.
  * @returns {Partial<T>} A new object with the properties that do not satisfy the predicate function.
  *
@@ -18,18 +16,6 @@ import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHe
  * const result = omitBy(obj, shouldOmit);
  * // result will be { a: 1, c: 3 }
  */
-function omitBy(obj, shouldOmit) {
-  var result = {};
-  for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      key = _Object$entries$_i[0],
-      value = _Object$entries$_i[1];
-    if (shouldOmit(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
-}
+declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: string) => boolean): Partial<T>;
 
 export { omitBy };

package/dist/object/omitBy.d.ts

@@ -16,4 +16,6 @@
  * const result = omitBy(obj, shouldOmit);
  * // result will be { a: 1, c: 3 }
  */
-export declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: string) => boolean): Partial<T>;
+declare function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: string) => boolean): Partial<T>;
+
+export { omitBy };

package/dist/object/omitBy.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/object/omitBy.ts
+var omitBy_exports = {};
+__export(omitBy_exports, {
+  omitBy: () => omitBy
+});
+module.exports = __toCommonJS(omitBy_exports);
+function omitBy(obj, shouldOmit) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (shouldOmit(value, key)) {
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  omitBy
+});
+//# sourceMappingURL=omitBy.js.map

package/dist/object/omitBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/object/omitBy.ts"],"sourcesContent":["/**\n * Creates a new object composed of the properties that do not satisfy the predicate function.\n *\n * This function takes an object and a predicate function, and returns a new object that\n * includes only the properties for which the predicate function returns false.\n *\n * @param {T} obj - The object to omit properties from.\n * @param {(value: T[string], key: string) => boolean} shouldOmit - A predicate function that determines\n * whether a property should be omitted. It takes the property's key and value as arguments and returns `true`\n * if the property should be omitted, and `false` otherwise.\n * @returns {Partial<T>} A new object with the properties that do not satisfy the predicate function.\n *\n * @example\n * const obj = { a: 1, b: 'omit', c: 3 };\n * const shouldOmit = (key, value) => typeof value === 'string';\n * const result = omitBy(obj, shouldOmit);\n * // result will be { a: 1, c: 3 }\n */\nexport function omitBy<T extends Record<string, any>>(\n  obj: T,\n  shouldOmit: (value: T[keyof T], key: string) => boolean\n): Partial<T> {\n  const result: Partial<T> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (shouldOmit(value, key)) {\n      continue;\n    }\n\n    (result as any)[key] = value;\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,SAAS,OACd,KACA,YACY;AACZ,QAAM,SAAqB,CAAC;AAE5B,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,WAAW,OAAO,GAAG,GAAG;AAC1B;AAAA,IACF;AAEA,IAAC,OAAe,GAAG,IAAI;AAAA,EACzB;AAEA,SAAO;AACT;","names":[]}

package/dist/object/omitBy.mjs

@@ -0,0 +1,8 @@
+import {
+  omitBy
+} from "../chunk-SF3V7XXM.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  omitBy
+};
+//# sourceMappingURL=omitBy.mjs.map

package/dist/object/omitBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/object/pick.mjs → dist/object/pick.d.mts}

@@ -1,9 +1,7 @@
-import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virtual/_rollupPluginBabelHelpers.mjs';
-
 /**
  * Creates a new object composed of the picked object properties.
  *
- * This function takes an object and an array of keys, and returns a new object that 
+ * This function takes an object and an array of keys, and returns a new object that
  * includes only the properties corresponding to the specified keys.
  *
  * @param {T} obj - The object to pick keys from.
@@ -15,21 +13,6 @@ import { createForOfIteratorHelper as _createForOfIteratorHelper } from './_virt
  * const result = pick(obj, ['a', 'c']);
  * // result will be { a: 1, c: 3 }
  */
-function pick(obj, keys) {
-  var result = {};
-  var _iterator = _createForOfIteratorHelper(keys),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var key = _step.value;
-      result[key] = obj[key];
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-  return result;
-}
+declare function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 
 export { pick };

package/dist/object/pick.d.ts

@@ -13,4 +13,6 @@
  * const result = pick(obj, ['a', 'c']);
  * // result will be { a: 1, c: 3 }
  */
-export declare function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+
+export { pick };

package/dist/object/pick.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/object/pick.ts
+var pick_exports = {};
+__export(pick_exports, {
+  pick: () => pick
+});
+module.exports = __toCommonJS(pick_exports);
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    result[key] = obj[key];
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pick
+});
+//# sourceMappingURL=pick.js.map

package/dist/object/pick.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/object/pick.ts"],"sourcesContent":["/**\n * Creates a new object composed of the picked object properties.\n *\n * This function takes an object and an array of keys, and returns a new object that\n * includes only the properties corresponding to the specified keys.\n *\n * @param {T} obj - The object to pick keys from.\n * @param {K[]} keys - An array of keys to be picked from the object.\n * @returns {Pick<T, K>} A new object with the specified keys picked.\n *\n * @example\n *  * const obj = { a: 1, b: 2, c: 3 };\n * const result = pick(obj, ['a', 'c']);\n * // result will be { a: 1, c: 3 }\n */\nexport function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n  const result = {} as Pick<T, K>;\n\n  for (const key of keys) {\n    result[key] = obj[key];\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,SAAS,KAA2B,KAAQ,MAAuB;AACxE,QAAM,SAAS,CAAC;AAEhB,aAAW,OAAO,MAAM;AACtB,WAAO,GAAG,IAAI,IAAI,GAAG;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/object/pick.mjs

@@ -0,0 +1,8 @@
+import {
+  pick
+} from "../chunk-AFYV2UVZ.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  pick
+};
+//# sourceMappingURL=pick.mjs.map

package/dist/object/pick.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/object/pickBy.mjs → dist/object/pickBy.d.mts}

@@ -1,14 +1,12 @@
-import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHelpers.mjs';
-
 /**
  * Creates a new object composed of the properties that satisfy the predicate function.
  *
- * This function takes an object and a predicate function, and returns a new object that 
+ * This function takes an object and a predicate function, and returns a new object that
  * includes only the properties for which the predicate function returns true.
  *
  * @param {T} obj - The object to pick properties from.
- * @param {(value: T[keyof T], key: string) => boolean} shouldPick - A predicate function that determines 
- * whether a property should be picked. It takes the property's key and value as arguments and returns `true` 
+ * @param {(value: T[keyof T], key: string) => boolean} shouldPick - A predicate function that determines
+ * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
  * if the property should be picked, and `false` otherwise.
  * @returns {Partial<T>} A new object with the properties that satisfy the predicate function.
  *
@@ -18,18 +16,6 @@ import { slicedToArray as _slicedToArray } from './_virtual/_rollupPluginBabelHe
  * const result = pickBy(obj, shouldPick);
  * // result will be { b: 'pick' }
  */
-function pickBy(obj, shouldPick) {
-  var result = {};
-  for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-      key = _Object$entries$_i[0],
-      value = _Object$entries$_i[1];
-    if (!shouldPick(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
-}
+declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: string) => boolean): Partial<T>;
 
 export { pickBy };

package/dist/object/pickBy.d.ts

@@ -16,4 +16,6 @@
  * const result = pickBy(obj, shouldPick);
  * // result will be { b: 'pick' }
  */
-export declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: string) => boolean): Partial<T>;
+declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: string) => boolean): Partial<T>;
+
+export { pickBy };

package/dist/object/pickBy.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/object/pickBy.ts
+var pickBy_exports = {};
+__export(pickBy_exports, {
+  pickBy: () => pickBy
+});
+module.exports = __toCommonJS(pickBy_exports);
+function pickBy(obj, shouldPick) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!shouldPick(value, key)) {
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pickBy
+});
+//# sourceMappingURL=pickBy.js.map

package/dist/object/pickBy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/object/pickBy.ts"],"sourcesContent":["/**\n * Creates a new object composed of the properties that satisfy the predicate function.\n *\n * This function takes an object and a predicate function, and returns a new object that\n * includes only the properties for which the predicate function returns true.\n *\n * @param {T} obj - The object to pick properties from.\n * @param {(value: T[keyof T], key: string) => boolean} shouldPick - A predicate function that determines\n * whether a property should be picked. It takes the property's key and value as arguments and returns `true`\n * if the property should be picked, and `false` otherwise.\n * @returns {Partial<T>} A new object with the properties that satisfy the predicate function.\n *\n * @example\n * const obj = { a: 1, b: 'pick', c: 3 };\n * const shouldPick = (value) => typeof value === 'string';\n * const result = pickBy(obj, shouldPick);\n * // result will be { b: 'pick' }\n */\nexport function pickBy<T extends Record<string, any>>(\n  obj: T,\n  shouldPick: (value: T[keyof T], key: string) => boolean\n): Partial<T> {\n  const result: Partial<T> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (!shouldPick(value, key)) {\n      continue;\n    }\n\n    (result as any)[key] = value;\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,SAAS,OACd,KACA,YACY;AACZ,QAAM,SAAqB,CAAC;AAE5B,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,CAAC,WAAW,OAAO,GAAG,GAAG;AAC3B;AAAA,IACF;AAEA,IAAC,OAAe,GAAG,IAAI;AAAA,EACzB;AAEA,SAAO;AACT;","names":[]}

package/dist/object/pickBy.mjs

@@ -0,0 +1,8 @@
+import {
+  pickBy
+} from "../chunk-T2C2WVFL.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  pickBy
+};
+//# sourceMappingURL=pickBy.mjs.map

package/dist/object/pickBy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/predicate/index.d.ts

@@ -1,4 +1,4 @@
-export { isNil } from './isNil';
-export { isNotNil } from './isNotNil';
-export { isNull } from './isNull';
-export { isUndefined } from './isUndefined';
+export { isNil } from './isNil.js';
+export { isNotNil } from './isNotNil.js';
+export { isNull } from './isNull.js';
+export { isUndefined } from './isUndefined.js';

package/dist/predicate/index.js

@@ -1,98 +1,56 @@
-'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, '__esModule', { value: true });
+// src/predicate/index.ts
+var predicate_exports = {};
+__export(predicate_exports, {
+  isNil: () => isNil,
+  isNotNil: () => isNotNil,
+  isNull: () => isNull,
+  isUndefined: () => isUndefined
+});
+module.exports = __toCommonJS(predicate_exports);
 
-/**
- * Checks if a given value is null or undefined.
- * 
- * This function tests whether the provided value is either `null` or `undefined`. 
- * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
- * 
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
- *
- * @param {unknown} x - The value to test for null or undefined.
- * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.
- *
- * @example
- *  * const value1 = null;
- * const value2 = undefined;
- * const value3 = 42;
- * const result1 = isNil(value1); // true
- * const result2 = isNil(value2); // true
- * const result3 = isNil(value3); // false
- */
+// src/predicate/isNil.ts
 function isNil(x) {
-  return x == null || x == undefined;
+  return x === null || x === void 0;
 }
 
-/**
- * Checks if the given value is not null nor undefined.
- * 
- * The main use of this function is to be used with TypeScript as a type predicate.
- *
- * @param {T | null | undefined} x - The value to test if it is not null nor undefined.
- * @returns {x is T} True if the value is not null nor undefined, false otherwise.
- *
- * @example
- * // Here the type of `arr` is (number | undefined)[]
- * const arr = [1, undefined, 3];
- * // Here the type of `result` is number[]
- * const result = arr.filter(isNotNil);
- * // result will be [1, 3]
- */
+// src/predicate/isNotNil.ts
 function isNotNil(x) {
-  return x != null && x != undefined;
+  return x !== null && x !== void 0;
 }
 
-/**
- * Checks if the given value is null.
- *
- * This function tests whether the provided value is strictly equal to `null`. 
- * It returns `true` if the value is `null`, and `false` otherwise.
- *
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`.
- * 
- * @param {unknown} x - The value to test if it is null.
- * @returns {x is null} True if the value is null, false otherwise.
- *
- * @example
- *  * const value1 = null;
- * const value2 = undefined;
- * const value3 = 42;
- * 
- * console.log(isNull(value1)); // true
- * console.log(isNull(value2)); // false
- * console.log(isNull(value3)); // false
- */
+// src/predicate/isNull.ts
 function isNull(x) {
   return x === null;
 }
 
-/**
- * Checks if the given value is undefined.
- *
- * This function tests whether the provided value is strictly equal to `undefined`. 
- * It returns `true` if the value is `undefined`, and `false` otherwise.
- * 
- * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`.
- *
- * @param {unknown} x - The value to test if it is undefined.
- * @returns {x is undefined} true if the value is undefined, false otherwise.
- *
- * @example
- *  * const value1 = undefined;
- * const value2 = null;
- * const value3 = 42;
- * 
- * console.log(isUndefined(value1)); // true
- * console.log(isUndefined(value2)); // false
- * console.log(isUndefined(value3)); // false
- */
+// src/predicate/isUndefined.ts
 function isUndefined(x) {
-  return x === undefined;
+  return x === void 0;
 }
-
-exports.isNil = isNil;
-exports.isNotNil = isNotNil;
-exports.isNull = isNull;
-exports.isUndefined = isUndefined;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNil,
+  isNotNil,
+  isNull,
+  isUndefined
+});
+//# sourceMappingURL=index.js.map

package/dist/predicate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/predicate/index.ts","../../src/predicate/isNil.ts","../../src/predicate/isNotNil.ts","../../src/predicate/isNull.ts","../../src/predicate/isUndefined.ts"],"sourcesContent":["export { isNil } from './isNil';\nexport { isNotNil } from './isNotNil';\nexport { isNull } from './isNull';\nexport { isUndefined } from './isUndefined';\n","/**\n * Checks if a given value is null or undefined.\n *\n * This function tests whether the provided value is either `null` or `undefined`.\n * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.\n *\n * @param {unknown} x - The value to test for null or undefined.\n * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.\n *\n * @example\n *  * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n * const result1 = isNil(value1); // true\n * const result2 = isNil(value2); // true\n * const result3 = isNil(value3); // false\n */\nexport function isNil(x: unknown): x is null | undefined {\n  return x === null || x === undefined;\n}\n","/**\n * Checks if the given value is not null nor undefined.\n *\n * The main use of this function is to be used with TypeScript as a type predicate.\n *\n * @param {T | null | undefined} x - The value to test if it is not null nor undefined.\n * @returns {x is T} True if the value is not null nor undefined, false otherwise.\n *\n * @example\n * // Here the type of `arr` is (number | undefined)[]\n * const arr = [1, undefined, 3];\n * // Here the type of `result` is number[]\n * const result = arr.filter(isNotNil);\n * // result will be [1, 3]\n */\nexport function isNotNil<T>(x: T | null | undefined): x is T {\n  return x !== null && x !== undefined;\n}\n","/**\n * Checks if the given value is null.\n *\n * This function tests whether the provided value is strictly equal to `null`.\n * It returns `true` if the value is `null`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`.\n *\n * @param {unknown} x - The value to test if it is null.\n * @returns {x is null} True if the value is null, false otherwise.\n *\n * @example\n *  * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n *\n * console.log(isNull(value1)); // true\n * console.log(isNull(value2)); // false\n * console.log(isNull(value3)); // false\n */\nexport function isNull(x: unknown): x is null {\n  return x === null;\n}\n","/**\n * Checks if the given value is undefined.\n *\n * This function tests whether the provided value is strictly equal to `undefined`.\n * It returns `true` if the value is `undefined`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`.\n *\n * @param {unknown} x - The value to test if it is undefined.\n * @returns {x is undefined} true if the value is undefined, false otherwise.\n *\n * @example\n *  * const value1 = undefined;\n * const value2 = null;\n * const value3 = 42;\n *\n * console.log(isUndefined(value1)); // true\n * console.log(isUndefined(value2)); // false\n * console.log(isUndefined(value3)); // false\n */\nexport function isUndefined(x: unknown): x is undefined {\n  return x === undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACmBO,SAAS,MAAM,GAAmC;AACvD,SAAO,MAAM,QAAQ,MAAM;AAC7B;;;ACNO,SAAS,SAAY,GAAiC;AAC3D,SAAO,MAAM,QAAQ,MAAM;AAC7B;;;ACGO,SAAS,OAAO,GAAuB;AAC5C,SAAO,MAAM;AACf;;;ACFO,SAAS,YAAY,GAA4B;AACtD,SAAO,MAAM;AACf;","names":[]}

package/dist/predicate/index.mjs

@@ -0,0 +1,21 @@
+import "../chunk-MAJSPFA6.mjs";
+import {
+  isNull
+} from "../chunk-Y6ZRNII6.mjs";
+import {
+  isUndefined
+} from "../chunk-HOQRMBSB.mjs";
+import {
+  isNil
+} from "../chunk-KBJTBR5T.mjs";
+import {
+  isNotNil
+} from "../chunk-ZQNAZPSK.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  isNil,
+  isNotNil,
+  isNull,
+  isUndefined
+};
+//# sourceMappingURL=index.mjs.map

package/dist/predicate/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/predicate/isNil.mjs → dist/predicate/isNil.d.mts}

@@ -1,9 +1,9 @@
 /**
  * Checks if a given value is null or undefined.
- * 
- * This function tests whether the provided value is either `null` or `undefined`. 
+ *
+ * This function tests whether the provided value is either `null` or `undefined`.
  * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.
- * 
+ *
  * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.
  *
  * @param {unknown} x - The value to test for null or undefined.
@@ -17,8 +17,6 @@
  * const result2 = isNil(value2); // true
  * const result3 = isNil(value3); // false
  */
-function isNil(x) {
-  return x == null || x == undefined;
-}
+declare function isNil(x: unknown): x is null | undefined;
 
 export { isNil };

package/dist/predicate/isNil.d.ts

@@ -17,4 +17,6 @@
  * const result2 = isNil(value2); // true
  * const result3 = isNil(value3); // false
  */
-export declare function isNil(x: unknown): x is null | undefined;
+declare function isNil(x: unknown): x is null | undefined;
+
+export { isNil };

package/dist/predicate/isNil.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/predicate/isNil.ts
+var isNil_exports = {};
+__export(isNil_exports, {
+  isNil: () => isNil
+});
+module.exports = __toCommonJS(isNil_exports);
+function isNil(x) {
+  return x === null || x === void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNil
+});
+//# sourceMappingURL=isNil.js.map

package/dist/predicate/isNil.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/predicate/isNil.ts"],"sourcesContent":["/**\n * Checks if a given value is null or undefined.\n *\n * This function tests whether the provided value is either `null` or `undefined`.\n * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.\n *\n * @param {unknown} x - The value to test for null or undefined.\n * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.\n *\n * @example\n *  * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n * const result1 = isNil(value1); // true\n * const result2 = isNil(value2); // true\n * const result3 = isNil(value3); // false\n */\nexport function isNil(x: unknown): x is null | undefined {\n  return x === null || x === undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBO,SAAS,MAAM,GAAmC;AACvD,SAAO,MAAM,QAAQ,MAAM;AAC7B;","names":[]}

package/dist/predicate/isNil.mjs

@@ -0,0 +1,8 @@
+import {
+  isNil
+} from "../chunk-KBJTBR5T.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  isNil
+};
+//# sourceMappingURL=isNil.mjs.map

package/dist/predicate/isNil.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/{esm/predicate/isNotNil.mjs → dist/predicate/isNotNil.d.mts}

@@ -1,6 +1,6 @@
 /**
  * Checks if the given value is not null nor undefined.
- * 
+ *
  * The main use of this function is to be used with TypeScript as a type predicate.
  *
  * @param {T | null | undefined} x - The value to test if it is not null nor undefined.
@@ -13,8 +13,6 @@
  * const result = arr.filter(isNotNil);
  * // result will be [1, 3]
  */
-function isNotNil(x) {
-  return x != null && x != undefined;
-}
+declare function isNotNil<T>(x: T | null | undefined): x is T;
 
 export { isNotNil };

package/dist/predicate/isNotNil.d.ts

@@ -13,4 +13,6 @@
  * const result = arr.filter(isNotNil);
  * // result will be [1, 3]
  */
-export declare function isNotNil<T>(x: T | null | undefined): x is T;
+declare function isNotNil<T>(x: T | null | undefined): x is T;
+
+export { isNotNil };