@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/is-deep-equal-CtBdM4eT.d.cts

@@ -0,0 +1,71 @@
+//#region src/is-deep-equal.d.ts
+/**
+ * Performs a *deep structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays the check would be performed on every item recursively, in order, and
+ * for objects all props will be compared recursively.
+ *
+ * The built-in Date and RegExp are special-cased and will be compared by their
+ * values.
+ *
+ * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
+ * right now and might result in unexpected behavior.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to
+ * check for simple (`===`, `Object.is`) equality.
+ * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
+ * don't want to recurse into their values.
+ *
+ * @param data - The first value to compare.
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isDeepEqual(data, other)
+ * @example
+ *    P.isDeepEqual(1, 1) //=> true
+ *    P.isDeepEqual(1, '1') //=> false
+ *    P.isDeepEqual([1, 2, 3], [1, 2, 3]) //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function isDeepEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
+declare function isDeepEqual<T>(data: T, other: T): boolean;
+/**
+ * Performs a *deep structural* comparison between two values to determine if
+ * they are equivalent. For primitive values this is equivalent to `===`, for
+ * arrays the check would be performed on every item recursively, in order, and
+ * for objects all props will be compared recursively.
+ *
+ * The built-in Date and RegExp are special-cased and will be compared by their
+ * values.
+ *
+ * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
+ * right now and might result in unexpected behavior.
+ *
+ * The result would be narrowed to the second value so that the function can be
+ * used as a type guard.
+ *
+ * See:
+ * - `isStrictEqual` if you don't need a deep comparison and just want to
+ * check for simple (`===`, `Object.is`) equality.
+ * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
+ * don't want to recurse into their values.
+ *
+ * @param other - The second value to compare.
+ * @signature
+ *    P.isDeepEqual(other)(data)
+ * @example
+ *    P.pipe(1, P.isDeepEqual(1)); //=> true
+ *    P.pipe(1, P.isDeepEqual('1')); //=> false
+ *    P.pipe([1, 2, 3], P.isDeepEqual([1, 2, 3])); //=> true
+ * @dataLast
+ * @category Guard
+ */
+declare function isDeepEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
+declare function isDeepEqual<T>(other: T): (data: T) => boolean;
+//#endregion
+export { isDeepEqual };
+//# sourceMappingURL=is-deep-equal-CtBdM4eT.d.cts.map

package/dist/is-deep-equal-CtBdM4eT.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal-CtBdM4eT.d.cts","names":[],"sources":["../src/is-deep-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;;AAIA;;;;;AAiCA;;;;;;;;;;;AAGA;;;;AAAkD,iBAxClC,WAwCkC,CAAA,CAAA,EAAA,UAxCT,CAwCS,CAAA,CAAA,IAAA,EAvC1C,CAuC0C,EAAA,KAAA,EAtCzC,CAsCyC,SAtC/B,OAsC+B,CAtCvB,CAsCuB,EAtCpB,CAsCoB,CAAA,GAtCf,CAsCe,GAAA,KAAA,CAAA,EAAA,IAAA,IArCvC,CAqCuC;iBApClC,qBAAqB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiC/B,yBAAyB,UAChC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,sBAAsB,WAAW"}

package/dist/is-deep-equal-D7dqs3e2.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||typeof t!=`object`||e===null||t===null||Object.getPrototypeOf(e)!==Object.getPrototypeOf(t))return!1;if(Array.isArray(e))return r(e,t);if(e instanceof Map)return i(e,t);if(e instanceof Set)return a(e,t);if(e instanceof Date)return e.getTime()===t.getTime();if(e instanceof RegExp)return e.toString()===t.toString();if(Object.keys(e).length!==Object.keys(t).length)return!1;for(let[r,i]of Object.entries(e))if(!(r in t)||!n(i,t[r]))return!1;return!0}function r(e,t){if(e.length!==t.length)return!1;for(let[r,i]of e.entries())if(!n(i,t[r]))return!1;return!0}function i(e,t){if(e.size!==t.size)return!1;for(let[r,i]of e.entries())if(!t.has(r)||!n(i,t.get(r)))return!1;return!0}function a(e,t){if(e.size!==t.size)return!1;let r=[...t];for(let t of e){let e=!1;for(let[i,a]of r.entries())if(n(t,a)){e=!0,r.splice(i,1);break}if(!e)return!1}return!0}export{t as isDeepEqual};
+//# sourceMappingURL=is-deep-equal-D7dqs3e2.js.map

package/dist/is-deep-equal-D7dqs3e2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal-D7dqs3e2.js","names":[],"sources":["../src/is-deep-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *deep structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays the check would be performed on every item recursively, in order, and\n * for objects all props will be compared recursively.\n *\n * The built-in Date and RegExp are special-cased and will be compared by their\n * values.\n *\n * !IMPORTANT: TypedArrays and symbol properties of objects are not supported\n * right now and might result in unexpected behavior.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to\n * check for simple (`===`, `Object.is`) equality.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isDeepEqual(data, other)\n * @example\n *    P.isDeepEqual(1, 1) //=> true\n *    P.isDeepEqual(1, '1') //=> false\n *    P.isDeepEqual([1, 2, 3], [1, 2, 3]) //=> true\n * @dataFirst\n * @category Guard\n */\nexport function isDeepEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isDeepEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *deep structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays the check would be performed on every item recursively, in order, and\n * for objects all props will be compared recursively.\n *\n * The built-in Date and RegExp are special-cased and will be compared by their\n * values.\n *\n * !IMPORTANT: TypedArrays and symbol properties of objects are not supported\n * right now and might result in unexpected behavior.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to\n * check for simple (`===`, `Object.is`) equality.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isDeepEqual(other)(data)\n * @example\n *    P.pipe(1, P.isDeepEqual(1)); //=> true\n *    P.pipe(1, P.isDeepEqual('1')); //=> false\n *    P.pipe([1, 2, 3], P.isDeepEqual([1, 2, 3])); //=> true\n * @dataLast\n * @category Guard\n */\nexport function isDeepEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isDeepEqual<T>(other: T): (data: T) => boolean;\n\nexport function isDeepEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isDeepEqualImplementation, args);\n}\n\nfunction isDeepEqualImplementation<T>(data: unknown, other: T): data is T {\n  if (data === other) {\n    return true;\n  }\n\n  if (Object.is(data, other)) {\n    // We want to ignore the slight differences between `===` and `Object.is` as\n    // both of them largely define equality from a semantic point-of-view.\n    return true;\n  }\n\n  if (typeof data !== 'object' || typeof other !== 'object') {\n    return false;\n  }\n\n  if (data === null || other === null) {\n    return false;\n  }\n\n  if (Object.getPrototypeOf(data) !== Object.getPrototypeOf(other)) {\n    // If the objects don't share a prototype it's unlikely that they are\n    // semantically equal. It is technically possible to build 2 prototypes that\n    // act the same but are not equal (at the reference level, checked via\n    // `===`) and then create 2 objects that are equal although we would fail on\n    // them. Because this is so unlikely, the optimization we gain here for the\n    // rest of the function by assuming that `other` is of the same type as\n    // `data` is more than worth it.\n    return false;\n  }\n\n  if (Array.isArray(data)) {\n    return isDeepEqualArrays(data, other as unknown as ReadonlyArray<unknown>);\n  }\n\n  if (data instanceof Map) {\n    return isDeepEqualMaps(data, other as unknown as Map<unknown, unknown>);\n  }\n\n  if (data instanceof Set) {\n    return isDeepEqualSets(data, other as unknown as Set<unknown>);\n  }\n\n  if (data instanceof Date) {\n    return data.getTime() === (other as unknown as Date).getTime();\n  }\n\n  if (data instanceof RegExp) {\n    return data.toString() === (other as unknown as RegExp).toString();\n  }\n\n  // At this point we only know that the 2 objects share a prototype and are not\n  // any of the previous types. They could be plain objects (Object.prototype),\n  // they could be classes, they could be other built-ins, or they could be\n  // something weird. We assume that comparing values by keys is enough to judge\n  // their equality.\n\n  if (Object.keys(data).length !== Object.keys(other).length) {\n    return false;\n  }\n\n  for (const [key, value] of Object.entries(data)) {\n    if (!(key in other)) {\n      return false;\n    }\n\n    if (\n      !isDeepEqualImplementation(\n        value,\n        // @ts-expect-error [ts7053] - We already checked that `other` has `key`\n        other[key],\n      )\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isDeepEqualArrays(\n  data: ReadonlyArray<unknown>,\n  other: ReadonlyArray<unknown>,\n): boolean {\n  if (data.length !== other.length) {\n    return false;\n  }\n\n  for (const [index, item] of data.entries()) {\n    if (!isDeepEqualImplementation(item, other[index])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isDeepEqualMaps(\n  data: ReadonlyMap<unknown, unknown>,\n  other: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (data.size !== other.size) {\n    return false;\n  }\n\n  for (const [key, value] of data.entries()) {\n    if (!other.has(key)) {\n      return false;\n    }\n\n    if (!isDeepEqualImplementation(value, other.get(key))) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isDeepEqualSets(\n  data: ReadonlySet<unknown>,\n  other: ReadonlySet<unknown>,\n): boolean {\n  if (data.size !== other.size) {\n    return false;\n  }\n\n  // To ensure we only count each item once we need to \"remember\" which items of\n  // the other set we've already matched against. We do this by creating a copy\n  // of the other set and removing items from it as we find them in the data\n  // set.\n  const otherCopy = [...other];\n\n  for (const dataItem of data) {\n    let isFound = false;\n\n    for (const [index, otherItem] of otherCopy.entries()) {\n      if (isDeepEqualImplementation(dataItem, otherItem)) {\n        isFound = true;\n        otherCopy.splice(index, 1);\n        break;\n      }\n    }\n\n    if (!isFound) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"4CA4EA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA6B,EAAe,EAAqB,CAKxE,GAJI,IAAS,GAIT,OAAO,GAAG,EAAM,EAAM,CAGxB,MAAO,GAWT,GARI,OAAO,GAAS,UAAY,OAAO,GAAU,UAI7C,IAAS,MAAQ,IAAU,MAI3B,OAAO,eAAe,EAAK,GAAK,OAAO,eAAe,EAAM,CAQ9D,MAAO,GAGT,GAAI,MAAM,QAAQ,EAAK,CACrB,OAAO,EAAkB,EAAM,EAA2C,CAG5E,GAAI,aAAgB,IAClB,OAAO,EAAgB,EAAM,EAA0C,CAGzE,GAAI,aAAgB,IAClB,OAAO,EAAgB,EAAM,EAAiC,CAGhE,GAAI,aAAgB,KAClB,OAAO,EAAK,SAAS,GAAM,EAA0B,SAAS,CAGhE,GAAI,aAAgB,OAClB,OAAO,EAAK,UAAU,GAAM,EAA4B,UAAU,CASpE,GAAI,OAAO,KAAK,EAAK,CAAC,SAAW,OAAO,KAAK,EAAM,CAAC,OAClD,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAK7C,GAJI,EAAE,KAAO,IAKX,CAAC,EACC,EAEA,EAAM,GACP,CAED,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAK,SAAW,EAAM,OACxB,MAAO,GAGT,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACxC,GAAI,CAAC,EAA0B,EAAM,EAAM,GAAO,CAChD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAK,OAAS,EAAM,KACtB,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAK,SAAS,CAKvC,GAJI,CAAC,EAAM,IAAI,EAAI,EAIf,CAAC,EAA0B,EAAO,EAAM,IAAI,EAAI,CAAC,CACnD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAK,OAAS,EAAM,KACtB,MAAO,GAOT,IAAM,EAAY,CAAC,GAAG,EAAM,CAE5B,IAAK,IAAM,KAAY,EAAM,CAC3B,IAAI,EAAU,GAEd,IAAK,GAAM,CAAC,EAAO,KAAc,EAAU,SAAS,CAClD,GAAI,EAA0B,EAAU,EAAU,CAAE,CAClD,EAAU,GACV,EAAU,OAAO,EAAO,EAAE,CAC1B,MAIJ,GAAI,CAAC,EACH,MAAO,GAIX,MAAO"}

package/dist/is-deep-equal-DR9xJg8D.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||typeof t!=`object`||e===null||t===null||Object.getPrototypeOf(e)!==Object.getPrototypeOf(t))return!1;if(Array.isArray(e))return r(e,t);if(e instanceof Map)return i(e,t);if(e instanceof Set)return a(e,t);if(e instanceof Date)return e.getTime()===t.getTime();if(e instanceof RegExp)return e.toString()===t.toString();if(Object.keys(e).length!==Object.keys(t).length)return!1;for(let[r,i]of Object.entries(e))if(!(r in t)||!n(i,t[r]))return!1;return!0}function r(e,t){if(e.length!==t.length)return!1;for(let[r,i]of e.entries())if(!n(i,t[r]))return!1;return!0}function i(e,t){if(e.size!==t.size)return!1;for(let[r,i]of e.entries())if(!t.has(r)||!n(i,t.get(r)))return!1;return!0}function a(e,t){if(e.size!==t.size)return!1;let r=[...t];for(let t of e){let e=!1;for(let[i,a]of r.entries())if(n(t,a)){e=!0,r.splice(i,1);break}if(!e)return!1}return!0}Object.defineProperty(exports,`isDeepEqual`,{enumerable:!0,get:function(){return t}});

package/dist/is-deep-equal.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHJ2H6KUHcjs = require('./chunk-HJ2H6KUH.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.isDeepEqual = _chunkHJ2H6KUHcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./is-deep-equal-DR9xJg8D.cjs`);exports.isDeepEqual=e.isDeepEqual;

package/dist/is-deep-equal.d.cts

@@ -1,69 +1,2 @@
-/**
- * Performs a *deep structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays the check would be performed on every item recursively, in order, and
- * for objects all props will be compared recursively.
- *
- * The built-in Date and RegExp are special-cased and will be compared by their
- * values.
- *
- * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
- * right now and might result in unexpected behavior.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to
- * check for simple (`===`, `Object.is`) equality.
- * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
- * don't want to recurse into their values.
- *
- * @param data - The first value to compare.
- * @param other - The second value to compare.
- * @signature
- *    P.isDeepEqual(data, other)
- * @example
- *    P.isDeepEqual(1, 1) //=> true
- *    P.isDeepEqual(1, '1') //=> false
- *    P.isDeepEqual([1, 2, 3], [1, 2, 3]) //=> true
- * @dataFirst
- * @category Guard
- */
-declare function isDeepEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isDeepEqual<T>(data: T, other: T): boolean;
-/**
- * Performs a *deep structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays the check would be performed on every item recursively, in order, and
- * for objects all props will be compared recursively.
- *
- * The built-in Date and RegExp are special-cased and will be compared by their
- * values.
- *
- * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
- * right now and might result in unexpected behavior.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to
- * check for simple (`===`, `Object.is`) equality.
- * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
- * don't want to recurse into their values.
- *
- * @param other - The second value to compare.
- * @signature
- *    P.isDeepEqual(other)(data)
- * @example
- *    P.pipe(1, P.isDeepEqual(1)); //=> true
- *    P.pipe(1, P.isDeepEqual('1')); //=> false
- *    P.pipe([1, 2, 3], P.isDeepEqual([1, 2, 3])); //=> true
- * @dataLast
- * @category Guard
- */
-declare function isDeepEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isDeepEqual<T>(other: T): (data: T) => boolean;
-
-export { isDeepEqual };
+import { isDeepEqual } from "./is-deep-equal-CtBdM4eT.cjs";
+export { isDeepEqual };

package/dist/is-deep-equal.d.ts

@@ -1,69 +1,2 @@
-/**
- * Performs a *deep structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays the check would be performed on every item recursively, in order, and
- * for objects all props will be compared recursively.
- *
- * The built-in Date and RegExp are special-cased and will be compared by their
- * values.
- *
- * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
- * right now and might result in unexpected behavior.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to
- * check for simple (`===`, `Object.is`) equality.
- * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
- * don't want to recurse into their values.
- *
- * @param data - The first value to compare.
- * @param other - The second value to compare.
- * @signature
- *    P.isDeepEqual(data, other)
- * @example
- *    P.isDeepEqual(1, 1) //=> true
- *    P.isDeepEqual(1, '1') //=> false
- *    P.isDeepEqual([1, 2, 3], [1, 2, 3]) //=> true
- * @dataFirst
- * @category Guard
- */
-declare function isDeepEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isDeepEqual<T>(data: T, other: T): boolean;
-/**
- * Performs a *deep structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays the check would be performed on every item recursively, in order, and
- * for objects all props will be compared recursively.
- *
- * The built-in Date and RegExp are special-cased and will be compared by their
- * values.
- *
- * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
- * right now and might result in unexpected behavior.
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isStrictEqual` if you don't need a deep comparison and just want to
- * check for simple (`===`, `Object.is`) equality.
- * - `isShallowEqual` if you need to compare arrays and objects "by-value" but
- * don't want to recurse into their values.
- *
- * @param other - The second value to compare.
- * @signature
- *    P.isDeepEqual(other)(data)
- * @example
- *    P.pipe(1, P.isDeepEqual(1)); //=> true
- *    P.pipe(1, P.isDeepEqual('1')); //=> false
- *    P.pipe([1, 2, 3], P.isDeepEqual([1, 2, 3])); //=> true
- * @dataLast
- * @category Guard
- */
-declare function isDeepEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isDeepEqual<T>(other: T): (data: T) => boolean;
-
-export { isDeepEqual };
+import { isDeepEqual } from "./is-deep-equal-C5PnLPx2.js";
+export { isDeepEqual };

package/dist/is-deep-equal.js

@@ -1 +1 @@
-import{a}from"./chunk-2IO5CTEV.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as isDeepEqual};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{isDeepEqual as e}from"./is-deep-equal-D7dqs3e2.js";export{e as isDeepEqual};

package/dist/is-defined-3Qp6lmQw.d.cts

@@ -0,0 +1,19 @@
+//#region src/is-defined.d.ts
+/**
+ * A function that checks if the passed parameter is defined (`!== undefined`)
+ * and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is defined, false otherwise.
+ * @signature
+ *    P.isDefined(data)
+ * @example
+ *    P.isDefined('string') //=> true
+ *    P.isDefined(null) //=> true
+ *    P.isDefined(undefined) //=> false
+ * @category Guard
+ */
+declare function isDefined<T>(data: T | undefined): data is T;
+//#endregion
+export { isDefined };
+//# sourceMappingURL=is-defined-3Qp6lmQw.d.cts.map

package/dist/is-defined-3Qp6lmQw.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined-3Qp6lmQw.d.cts","names":[],"sources":["../src/is-defined.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;;;iBAAgB,mBAAmB,wBAAwB"}

package/dist/is-defined-Bjs-PriY.d.ts

@@ -0,0 +1,19 @@
+//#region src/is-defined.d.ts
+/**
+ * A function that checks if the passed parameter is defined (`!== undefined`)
+ * and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is defined, false otherwise.
+ * @signature
+ *    P.isDefined(data)
+ * @example
+ *    P.isDefined('string') //=> true
+ *    P.isDefined(null) //=> true
+ *    P.isDefined(undefined) //=> false
+ * @category Guard
+ */
+declare function isDefined<T>(data: T | undefined): data is T;
+//#endregion
+export { isDefined };
+//# sourceMappingURL=is-defined-Bjs-PriY.d.ts.map

package/dist/is-defined-Bjs-PriY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined-Bjs-PriY.d.ts","names":[],"sources":["../src/is-defined.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;;;;;;;;;iBAAgB,mBAAmB,wBAAwB"}

package/dist/is-defined-BnbPFPUx.cjs

@@ -0,0 +1 @@
+function e(e){return e!==void 0}Object.defineProperty(exports,`isDefined`,{enumerable:!0,get:function(){return e}});

package/dist/is-defined-bdl8LRyD.js

@@ -0,0 +1,2 @@
+function e(e){return e!==void 0}export{e as isDefined};
+//# sourceMappingURL=is-defined-bdl8LRyD.js.map

package/dist/is-defined-bdl8LRyD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined-bdl8LRyD.js","names":[],"sources":["../src/is-defined.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is defined (`!== undefined`)\n * and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined, false otherwise.\n * @signature\n *    P.isDefined(data)\n * @example\n *    P.isDefined('string') //=> true\n *    P.isDefined(null) //=> true\n *    P.isDefined(undefined) //=> false\n * @category Guard\n */\nexport function isDefined<T>(data: T | undefined): data is T {\n  return data !== undefined;\n}\n"],"mappings":"AAcA,SAAgB,EAAa,EAAgC,CAC3D,OAAO,IAAS,IAAA"}

package/dist/is-defined.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYSTUBBOJcjs = require('./chunk-YSTUBBOJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.isDefined = _chunkYSTUBBOJcjs.a;
+const e=require(`./is-defined-BnbPFPUx.cjs`);exports.isDefined=e.isDefined;

package/dist/is-defined.d.cts

@@ -1,17 +1,2 @@
-/**
- * A function that checks if the passed parameter is defined (`!== undefined`)
- * and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is defined, false otherwise.
- * @signature
- *    P.isDefined(data)
- * @example
- *    P.isDefined('string') //=> true
- *    P.isDefined(null) //=> true
- *    P.isDefined(undefined) //=> false
- * @category Guard
- */
-declare function isDefined<T>(data: T | undefined): data is T;
-
-export { isDefined };
+import { isDefined } from "./is-defined-3Qp6lmQw.cjs";
+export { isDefined };

package/dist/is-defined.d.ts

@@ -1,17 +1,2 @@
-/**
- * A function that checks if the passed parameter is defined (`!== undefined`)
- * and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is defined, false otherwise.
- * @signature
- *    P.isDefined(data)
- * @example
- *    P.isDefined('string') //=> true
- *    P.isDefined(null) //=> true
- *    P.isDefined(undefined) //=> false
- * @category Guard
- */
-declare function isDefined<T>(data: T | undefined): data is T;
-
-export { isDefined };
+import { isDefined } from "./is-defined-Bjs-PriY.js";
+export { isDefined };

package/dist/is-defined.js

@@ -1 +1 @@
-import{a}from"./chunk-DNSXSQCO.js";import"./chunk-EK7ODJWE.js";export{a as isDefined};
+import{isDefined as e}from"./is-defined-bdl8LRyD.js";export{e as isDefined};

package/dist/is-empty-BSkgk0sE.js

@@ -0,0 +1,2 @@
+function e(e){return e===void 0?!0:typeof e==`string`||Array.isArray(e)?e.length===0:Object.keys(e).length===0}export{e as isEmpty};
+//# sourceMappingURL=is-empty-BSkgk0sE.js.map

package/dist/is-empty-BSkgk0sE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-BSkgk0sE.js","names":[],"sources":["../src/is-empty.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\n/**\n * A function that checks if the passed parameter is empty.\n *\n * `undefined` is also considered empty, but only when it's in a union with a\n * `string` or string-like type.\n *\n * This guard doesn't work negated because of typescript limitations! If you\n * need to check that an array is *not* empty, use `P.hasAtLeast(data, 1)`\n * and not `!P.isEmpty(data)`. For strings and objects there's no way in\n * typescript to narrow the result to a non-empty type.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is empty, false otherwise.\n * @signature\n *    P.isEmpty(data)\n * @example\n *    P.isEmpty(undefined) //=>true\n *    P.isEmpty('') //=> true\n *    P.isEmpty([]) //=> true\n *    P.isEmpty({}) //=> true\n *    P.isEmpty('test') //=> false\n *    P.isEmpty([1, 2, 3]) //=> false\n *    P.isEmpty({ length: 0 }) //=> false\n * @category Guard\n */\nexport function isEmpty<T extends string | undefined>(\n  data: T,\n): data is\n  | ('' extends T ? '' : never)\n  | (undefined extends T ? undefined : never);\nexport function isEmpty(data: IterableContainer): data is [];\nexport function isEmpty<T extends object>(\n  data: T,\n): data is Record<keyof T, never>;\n\nexport function isEmpty(data: object | string | undefined): boolean {\n  if (data === undefined) {\n    return true;\n  }\n\n  if (typeof data === 'string') {\n    return data.length === 0;\n  }\n\n  if (Array.isArray(data)) {\n    return data.length === 0;\n  }\n\n  return Object.keys(data).length === 0;\n}\n"],"mappings":"AAqCA,SAAgB,EAAQ,EAA4C,CAalE,OAZI,IAAS,IAAA,GACJ,GAGL,OAAO,GAAS,UAIhB,MAAM,QAAQ,EAAK,CACd,EAAK,SAAW,EAGlB,OAAO,KAAK,EAAK,CAAC,SAAW"}

package/dist/is-empty-CFT22qg4.d.cts

@@ -0,0 +1,35 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#region src/is-empty.d.ts
+
+/**
+ * A function that checks if the passed parameter is empty.
+ *
+ * `undefined` is also considered empty, but only when it's in a union with a
+ * `string` or string-like type.
+ *
+ * This guard doesn't work negated because of typescript limitations! If you
+ * need to check that an array is *not* empty, use `P.hasAtLeast(data, 1)`
+ * and not `!P.isEmpty(data)`. For strings and objects there's no way in
+ * typescript to narrow the result to a non-empty type.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is empty, false otherwise.
+ * @signature
+ *    P.isEmpty(data)
+ * @example
+ *    P.isEmpty(undefined) //=>true
+ *    P.isEmpty('') //=> true
+ *    P.isEmpty([]) //=> true
+ *    P.isEmpty({}) //=> true
+ *    P.isEmpty('test') //=> false
+ *    P.isEmpty([1, 2, 3]) //=> false
+ *    P.isEmpty({ length: 0 }) //=> false
+ * @category Guard
+ */
+declare function isEmpty<T extends string | undefined>(data: T): data is ('' extends T ? '' : never) | (undefined extends T ? undefined : never);
+declare function isEmpty(data: IterableContainer): data is [];
+declare function isEmpty<T extends object>(data: T): data is Record<keyof T, never>;
+//#endregion
+export { isEmpty };
+//# sourceMappingURL=is-empty-CFT22qg4.d.cts.map

package/dist/is-empty-CFT22qg4.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-CFT22qg4.d.cts","names":[],"sources":["../src/is-empty.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;AAKA;AACA;;;;;;;;;;;;;;;;iBANgB,4CACR,wBAEQ,qCACO;iBACP,OAAA,OAAc;iBACd,gCACR,YACG,aAAa"}

package/dist/is-empty-DumZFkEX.d.ts

@@ -0,0 +1,35 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+
+//#region src/is-empty.d.ts
+
+/**
+ * A function that checks if the passed parameter is empty.
+ *
+ * `undefined` is also considered empty, but only when it's in a union with a
+ * `string` or string-like type.
+ *
+ * This guard doesn't work negated because of typescript limitations! If you
+ * need to check that an array is *not* empty, use `P.hasAtLeast(data, 1)`
+ * and not `!P.isEmpty(data)`. For strings and objects there's no way in
+ * typescript to narrow the result to a non-empty type.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is empty, false otherwise.
+ * @signature
+ *    P.isEmpty(data)
+ * @example
+ *    P.isEmpty(undefined) //=>true
+ *    P.isEmpty('') //=> true
+ *    P.isEmpty([]) //=> true
+ *    P.isEmpty({}) //=> true
+ *    P.isEmpty('test') //=> false
+ *    P.isEmpty([1, 2, 3]) //=> false
+ *    P.isEmpty({ length: 0 }) //=> false
+ * @category Guard
+ */
+declare function isEmpty<T extends string | undefined>(data: T): data is ('' extends T ? '' : never) | (undefined extends T ? undefined : never);
+declare function isEmpty(data: IterableContainer): data is [];
+declare function isEmpty<T extends object>(data: T): data is Record<keyof T, never>;
+//#endregion
+export { isEmpty };
+//# sourceMappingURL=is-empty-DumZFkEX.d.ts.map

package/dist/is-empty-DumZFkEX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-DumZFkEX.d.ts","names":[],"sources":["../src/is-empty.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;AAKA;AACA;;;;;;;;;;;;;;;;iBANgB,4CACR,wBAEQ,qCACO;iBACP,OAAA,OAAc;iBACd,gCACR,YACG,aAAa"}

package/dist/is-empty-s3B43K38.cjs

@@ -0,0 +1 @@
+function e(e){return e===void 0?!0:typeof e==`string`||Array.isArray(e)?e.length===0:Object.keys(e).length===0}Object.defineProperty(exports,`isEmpty`,{enumerable:!0,get:function(){return e}});

package/dist/is-empty.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkTRIZIXDAcjs = require('./chunk-TRIZIXDA.cjs');require('./chunk-MBGSSEZN.cjs');exports.isEmpty = _chunkTRIZIXDAcjs.a;
+const e=require(`./is-empty-s3B43K38.cjs`);exports.isEmpty=e.isEmpty;

package/dist/is-empty.d.cts

@@ -1,32 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-
-/**
- * A function that checks if the passed parameter is empty.
- *
- * `undefined` is also considered empty, but only when it's in a union with a
- * `string` or string-like type.
- *
- * This guard doesn't work negated because of typescript limitations! If you
- * need to check that an array is *not* empty, use `P.hasAtLeast(data, 1)`
- * and not `!P.isEmpty(data)`. For strings and objects there's no way in
- * typescript to narrow the result to a non-empty type.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is empty, false otherwise.
- * @signature
- *    P.isEmpty(data)
- * @example
- *    P.isEmpty(undefined) //=>true
- *    P.isEmpty('') //=> true
- *    P.isEmpty([]) //=> true
- *    P.isEmpty({}) //=> true
- *    P.isEmpty('test') //=> false
- *    P.isEmpty([1, 2, 3]) //=> false
- *    P.isEmpty({ length: 0 }) //=> false
- * @category Guard
- */
-declare function isEmpty<T extends string | undefined>(data: T): data is ('' extends T ? '' : never) | (undefined extends T ? undefined : never);
-declare function isEmpty(data: IterableContainer): data is [];
-declare function isEmpty<T extends object>(data: T): data is Record<keyof T, never>;
-
-export { isEmpty };
+import "./iterable-container-V5sa0V_H.cjs";
+import { isEmpty } from "./is-empty-CFT22qg4.cjs";
+export { isEmpty };

package/dist/is-empty.d.ts

@@ -1,32 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-
-/**
- * A function that checks if the passed parameter is empty.
- *
- * `undefined` is also considered empty, but only when it's in a union with a
- * `string` or string-like type.
- *
- * This guard doesn't work negated because of typescript limitations! If you
- * need to check that an array is *not* empty, use `P.hasAtLeast(data, 1)`
- * and not `!P.isEmpty(data)`. For strings and objects there's no way in
- * typescript to narrow the result to a non-empty type.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is empty, false otherwise.
- * @signature
- *    P.isEmpty(data)
- * @example
- *    P.isEmpty(undefined) //=>true
- *    P.isEmpty('') //=> true
- *    P.isEmpty([]) //=> true
- *    P.isEmpty({}) //=> true
- *    P.isEmpty('test') //=> false
- *    P.isEmpty([1, 2, 3]) //=> false
- *    P.isEmpty({ length: 0 }) //=> false
- * @category Guard
- */
-declare function isEmpty<T extends string | undefined>(data: T): data is ('' extends T ? '' : never) | (undefined extends T ? undefined : never);
-declare function isEmpty(data: IterableContainer): data is [];
-declare function isEmpty<T extends object>(data: T): data is Record<keyof T, never>;
-
-export { isEmpty };
+import "./iterable-container-F9CDF7ym.js";
+import { isEmpty } from "./is-empty-DumZFkEX.js";
+export { isEmpty };

package/dist/is-empty.js

@@ -1 +1 @@
-import{a}from"./chunk-UVAWCZB6.js";import"./chunk-EK7ODJWE.js";export{a as isEmpty};
+import{isEmpty as e}from"./is-empty-BSkgk0sE.js";export{e as isEmpty};

package/dist/is-emptyish-CtpYRY75.cjs

@@ -0,0 +1 @@
+function e(e){if(e==null||e===``)return!0;if(typeof e!=`object`)return!1;if(`length`in e&&typeof e.length==`number`)return e.length===0;if(`size`in e&&typeof e.size==`number`)return e.size===0;for(let t in e)return!1;return Object.getOwnPropertySymbols(e).length===0}Object.defineProperty(exports,`isEmptyish`,{enumerable:!0,get:function(){return e}});

package/dist/is-emptyish-DAVU8RH1.d.cts

@@ -0,0 +1,74 @@
+import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
+import { NoInfer } from "./no-infer-CFhWzPzc.cjs";
+import { And, HasRequiredKeys, IsAny, IsEqual, IsNever, IsNumericLiteral, IsUnknown, OmitIndexSignature, Or, Tagged, ValueOf } from "type-fest";
+
+//#region src/internal/types/has-writable-keys.d.ts
+type HasWritableKeys<T> = IsEqual<Readonly<T>, T> extends true ? false : true;
+//#endregion
+//#region src/is-emptyish.d.ts
+declare const EMPTYISH_BRAND: unique symbol;
+type Empty<T> = Tagged<T, typeof EMPTYISH_BRAND>;
+type Emptyish<T> = (T extends string ? '' : never) | (T extends object ? EmptyishObjectLike<T> : never) | (T extends null ? null : never) | (T extends undefined ? undefined : never);
+type EmptyishObjectLike<T extends object> = T extends ReadonlyArray<unknown> ? EmptyishArray<T> : T extends ReadonlyMap<infer Key, unknown> ? T extends Map<unknown, unknown> ? Empty<T> : ReadonlyMap<Key, never> : T extends ReadonlySet<unknown> ? T extends Set<unknown> ? Empty<T> : ReadonlySet<never> : EmptyishObject<T>;
+type EmptyishArray<T extends ReadonlyArray<unknown>> = T extends readonly [] ? T : And<IsEqual<TupleParts<T>['required'], []>, IsEqual<TupleParts<T>['suffix'], []>> extends true ? T extends Array<unknown> ? Empty<T> : readonly [] : never;
+type EmptyishObject<T extends object> = T extends {
+  length: infer Length extends number;
+} ? T extends string ? never : EmptyishArbitrary<T, Length> : T extends {
+  size: infer Size extends number;
+} ? EmptyishArbitrary<T, Size> : IsNever<ValueOf<T>> extends true ? T : HasRequiredKeys<OmitIndexSignature<T>> extends true ? never : HasWritableKeys<T> extends true ? Empty<T> : { readonly [P in keyof T]: never };
+type EmptyishArbitrary<T, N> = IsNumericLiteral<N> extends true ? [0] extends [N] ? [N] extends [0] ? T : Empty<T> : never : Empty<T>;
+type ShouldNotNarrow<T> = Or<Or<IsAny<T>, IsUnknown<T>>, IsEqual<T, {}>>;
+/**
+ * A function that checks if the input is empty. Empty is defined as anything
+ * exposing a numerical `length`, or `size` property that is equal to `0`. This
+ * definition covers strings, arrays, Maps, Sets, plain objects, and custom
+ * classes. Additionally, `null` and `undefined` are also considered empty.
+ *
+ * `number`, `bigint`, `boolean`, `symbol`, and `function` will always return
+ * `false`. `RegExp`, `Date`, and weak collections will always return `true`.
+ * Classes and Errors are treated as plain objects: if they expose any public
+ * property they would be considered non-empty, unless they expose a numerical
+ * `length` or `size` property, which defines their emptiness regardless of
+ * other properties.
+ *
+ * This function has *limited* utility at the type level because **negating** it
+ * does not yield a useful type in most cases because of TypeScript
+ * limitations. Additionally, utilities which accept a narrower input type
+ * provide better type-safety on their inputs. In most cases, you should use
+ * one of the following functions instead:
+ * `isEmpty` - provides better type-safety on inputs by accepting a narrower set of cases.
+ * `hasAtLeast` - when the input is just an array/tuple.
+ * `isStrictEqual` - when you just need to check for a specific literal value.
+ * `isNullish` - when you just care about `null` and `undefined`.
+ * `isTruthy` - when you need to also filter `number` and `boolean`.
+ *
+ * @param data - The variable to check.
+ * @signature
+ *    P.isEmptyish(data)
+ * @example
+ *    P.isEmptyish(undefined); //=> true
+ *    P.isEmptyish(null); //=> true
+ *    P.isEmptyish(''); //=> true
+ *    P.isEmptyish([]); //=> true
+ *    P.isEmptyish({}); //=> true
+ *    P.isEmptyish(new Map()); //=> true
+ *    P.isEmptyish(new Set()); //=> true
+ *    P.isEmptyish({ a: "hello", size: 0 }); //=> true
+ *    P.isEmptyish(/abc/); //=> true
+ *    P.isEmptyish(new Date()); //=> true
+ *    P.isEmptyish(new WeakMap()); //=> true
+ *
+ *    P.isEmptyish('test'); //=> false
+ *    P.isEmptyish([1, 2, 3]); //=> false
+ *    P.isEmptyish({ a: "hello" }); //=> false
+ *    P.isEmptyish({ length: 1 }); //=> false
+ *    P.isEmptyish(0); //=> false
+ *    P.isEmptyish(true); //=> false
+ *    P.isEmptyish(() => {}); //=> false
+ * @category Guard
+ */
+declare function isEmptyish<T>(data: ShouldNotNarrow<T> extends true ? never : T | Readonly<Emptyish<NoInfer<T>>>): data is ShouldNotNarrow<T> extends true ? never : T extends unknown ? Emptyish<NoInfer<T>> : never;
+declare function isEmptyish(data: unknown): boolean;
+//#endregion
+export { isEmptyish };
+//# sourceMappingURL=is-emptyish-DAVU8RH1.d.cts.map

package/dist/is-emptyish-DAVU8RH1.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-emptyish-DAVU8RH1.d.cts","names":[],"sources":["../src/internal/types/has-writable-keys.ts","../src/is-emptyish.ts"],"sourcesContent":[],"mappings":"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"}