@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/intersection-with-J-TfLFKn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection-with-J-TfLFKn.d.ts","names":[],"sources":["../src/intersection-with.ts"],"sourcesContent":[],"mappings":";KAKK,kCAAkC,WAAW;;;;;;AAwBlD;;;;;;;;;;;;AA0BA;;;;;AAMiC,iBAhCjB,gBAgCiB,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,KAAA,EA/BxB,aA+BwB,CA/BV,MA+BU,CAAA,EAAA,KAAA,EA9BxB,aA8BwB,CA9BV,OA8BU,CAAA,EAAA,UAAA,EA7BnB,UA6BmB,CA7BR,MA6BQ,EA7BA,OA6BA,CAAA,CAAA,EA5B9B,KA4B8B,CA5BxB,MA4BwB,CAAA;;;;;;;;;;;;;;;;;;;;;iBANjB,yCACP,cAAc;;;;;YAKT,WAAW,QAAQ,mBACtB,cAAc,YAAY,MAAM"}

package/dist/intersection-with.d.ts

@@ -1,2 +1,2 @@
-import { intersectionWith } from "./intersection-with-COmRebRq.js";
+import { intersectionWith } from "./intersection-with-J-TfLFKn.js";
 export { intersectionWith };

package/dist/intersection.d.ts

@@ -1,2 +1,2 @@
-import { intersection } from "./intersection-DJQJxp9k.js";
+import { intersection } from "./intersection-C7uJ0cq1.js";
 export { intersection };

package/dist/invert-V1ZPyP7T.d.ts

@@ -0,0 +1,33 @@
+import { ToString } from "./to-string-B9YWszXY.js";
+import { Simplify } from "type-fest";
+
+//#region src/invert.d.ts
+type Inverted<T extends object> = Simplify<{ -readonly [K in keyof T as K extends number | string ? Required<T>[K] extends PropertyKey ? Required<T>[K] : never : never]: ToString<K> }>;
+/**
+ * Returns an object whose keys and values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ *
+ * @param object - The object.
+ * @signature
+ *    P.invert(object)
+ * @example
+ *    P.invert({ a: "d", b: "e", c: "f" }) // => { d: "a", e: "b", f: "c" }
+ * @dataFirst
+ * @category Object
+ */
+declare function invert<T extends object>(object: T): Inverted<T>;
+/**
+ * Returns an object whose keys and values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ *
+ * @signature
+ *    P.invert()(object)
+ * @example
+ *    P.pipe({ a: "d", b: "e", c: "f" }, P.invert()); // => { d: "a", e: "b", f: "c" }
+ * @dataLast
+ * @category Object
+ */
+declare function invert<T extends object>(): (object: T) => Inverted<T>;
+//#endregion
+export { invert };
+//# sourceMappingURL=invert-V1ZPyP7T.d.ts.map

package/dist/invert-V1ZPyP7T.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert-V1ZPyP7T.d.ts","names":[],"sources":["../src/invert.ts"],"sourcesContent":[],"mappings":";;;;KAKK,6BAA6B,iCACV,KAAK,4BACvB,SAAS,GAAG,WAAW,cACrB,SAAS,GAAG,qBAEN,SAAS,IARoC,CAAA;;;;;;;;;;;;;AAGzB,iBAoBlB,MApBkB,CAAA,UAAA,MAAA,CAAA,CAAA,MAAA,EAoBe,CApBf,CAAA,EAoBmB,QApBnB,CAoB4B,CApB5B,CAAA;;AAoBlC;;;;;;AAaA;;;;AAA2D,iBAA3C,MAA2C,CAAA,UAAA,MAAA,CAAA,CAAA,CAAA,EAAA,CAAA,MAAA,EAAN,CAAM,EAAA,GAAA,QAAA,CAAS,CAAT,CAAA"}

package/dist/invert.d.ts

@@ -1,3 +1,3 @@
-import "./to-string-RweoJgSy.js";
-import { invert } from "./invert-DMSQXxyb.js";
+import "./to-string-B9YWszXY.js";
+import { invert } from "./invert-V1ZPyP7T.js";
 export { invert };

package/dist/is-array-DWisKd2S.d.ts

@@ -0,0 +1,21 @@
+import { NarrowedTo } from "./narrowed-to-BLLrlAhb.js";
+
+//#region src/is-array.d.ts
+
+/**
+ * A function that checks if the passed parameter is an Array and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is an Array, false otherwise.
+ * @signature
+ *    P.isArray(data)
+ * @example
+ *    P.isArray([5]) //=> true
+ *    P.isArray([]) //=> true
+ *    P.isArray('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isArray<T>(data: ArrayLike<unknown> | T): data is NarrowedTo<T, ReadonlyArray<unknown>>;
+//#endregion
+export { isArray };
+//# sourceMappingURL=is-array-DWisKd2S.d.ts.map

package/dist/is-array-DWisKd2S.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array-DWisKd2S.d.ts","names":[],"sources":["../src/is-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAeA;;;;;;;;;;;iBAAgB,iBACR,qBAAqB,YAClB,WAAW,GAAG"}

package/dist/is-array.d.ts

@@ -1,3 +1,3 @@
-import "./narrowed-to-C6wP224-.js";
-import { isArray } from "./is-array-prXR4sUC.js";
+import "./narrowed-to-BLLrlAhb.js";
+import { isArray } from "./is-array-DWisKd2S.js";
 export { isArray };

package/dist/is-big-int-DmUEnRHP.d.ts

@@ -0,0 +1,22 @@
+import { NarrowedTo } from "./narrowed-to-BLLrlAhb.js";
+
+//#region src/is-big-int.d.ts
+
+/**
+ * A function that checks if the passed parameter is a bigint and narrows its
+ * type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a number, false otherwise.
+ * @signature
+ *    P.isBigInt(data)
+ * @example
+ *    P.isBigInt(1n); // => true
+ *    P.isBigInt(1); // => false
+ *    P.isBigInt('notANumber'); // => false
+ * @category Guard
+ */
+declare function isBigInt<T>(data: bigint | T): data is NarrowedTo<T, bigint>;
+//#endregion
+export { isBigInt };
+//# sourceMappingURL=is-big-int-DmUEnRHP.d.ts.map

package/dist/is-big-int-DmUEnRHP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-big-int-DmUEnRHP.d.ts","names":[],"sources":["../src/is-big-int.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;;;;;;iBAAgB,2BAA2B,YAAY,WAAW"}

package/dist/is-big-int.d.ts

@@ -1,3 +1,3 @@
-import "./narrowed-to-C6wP224-.js";
-import { isBigInt } from "./is-big-int-e123CwI2.js";
+import "./narrowed-to-BLLrlAhb.js";
+import { isBigInt } from "./is-big-int-DmUEnRHP.js";
 export { isBigInt };

package/dist/is-boolean-BSqxj-_d.d.ts

@@ -0,0 +1,21 @@
+import { NarrowedTo } from "./narrowed-to-BLLrlAhb.js";
+
+//#region src/is-boolean.d.ts
+
+/**
+ * A function that checks if the passed parameter is a boolean and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a boolean, false otherwise.
+ * @signature
+ *    P.isBoolean(data)
+ * @example
+ *    P.isBoolean(true) //=> true
+ *    P.isBoolean(false) //=> true
+ *    P.isBoolean('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isBoolean<T>(data: boolean | T): data is NarrowedTo<T, boolean>;
+//#endregion
+export { isBoolean };
+//# sourceMappingURL=is-boolean-BSqxj-_d.d.ts.map

package/dist/is-boolean-BSqxj-_d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-boolean-BSqxj-_d.d.ts","names":[],"sources":["../src/is-boolean.ts"],"sourcesContent":[],"mappings":";;;;;;AAeA;;;;;;;;;;;iBAAgB,6BACE,YACP,WAAW"}

package/dist/is-boolean.d.ts

@@ -1,3 +1,3 @@
-import "./narrowed-to-C6wP224-.js";
-import { isBoolean } from "./is-boolean-DWuHhrIe.js";
+import "./narrowed-to-BLLrlAhb.js";
+import { isBoolean } from "./is-boolean-BSqxj-_d.js";
 export { isBoolean };

package/dist/is-bounded-record-DEQ2a3_Y.d.ts

@@ -0,0 +1,34 @@
+import { IsNumericLiteral, IsStringLiteral, IsSymbolLiteral, KeysOfUnion, Or, Split } from "type-fest";
+
+//#region src/internal/types/is-bounded.d.ts
+
+/**
+ * Checks if a type is a bounded key: a union of bounded strings, numeric
+ * literals, or symbol literals.
+ *
+ * [For an interactive deeper dive and explanation see the following playground](https://www.typescriptlang.org/play/?noUncheckedIndexedAccess=true#code/PTAEBUAsEsGdQE4FMDGB7BATUdQCIAjNAVwDtMlM8AaHAF1EgEN4nQAzaU6OpUWJAzTtQAayQBPWADpQASQZMANrDSIkAR2LRk8HgHJYAKBCg0BAFaoGdNcwBufZUrMi6kJAFtpRuhIAOfABCJOSUoAC8oABKqBiYADwABv7InAAeAPoAJADeeB5KSmh4oAA++ADuGEpUAL5JtHiqnoIwpADmeAB8ANxGJmBQuMjoWDjweGREZBRUtDyMLKBMpDiknNy8-IKuoP5osLDQBEp84lKyCoaDZpbWoOjEtY9opHRMXKCkb3zCoO4vAC0GgfH5AqAAKqkGZhbBRWJjRIpNLQLJ5WB0BBcDoNJotNo4nr9W4AMQwK1IEggAC4IKAkOleOR4AAFJgIOjQZQJcDdUAEakUTZct60AjEGwedaOBACCbfNCKJSVJhSW5Y4hIWQAdQ8a0WuE1fEqfBQq34aoBzAY4AV0E8-iU0BQPCU1P8HK5ylAAApDcZTJptPZlEh3sDQOzOdylLzugBKXwBPhyWByR3O110d3R71xvmRKNe2PxhlM8OYeB2gD8+AkpTpeFIeBJpj14ZWKBQSCOOJW+wQaH8e0BAtCczuVhQtpTAGUUNj-AxzWtw7BiMhrUwGKlh7dGXA6Ho1mPzNPFOQGaQN1uePBwdqjBQUEoOWa3pjQEEAPKQgByAAiACigF0iEsyUP06A3gwsKTlEv4ASBgEANp4KkSAZJkhTFHgAC6-SmKAJEAHo1gM7b6l2PZ9p0A57iO-xjtME7hOe1i0JU1H6D80IoB4KDiJgchhOklAAILdr2sBJLcuDhkwpzhOA86LtAy6PBabzutet4mjaAIpvQoAAFSeNAHSQHQpkCkg4qSisKhoLcMHHBQCDWmaLAGUgd4MJgaC9qQ+gMIeX5fGe9wzrQqgmU8LzKHFBBILcSSQZslBJD4L5vlubkMABSFAaBdLQvBUFGAVoCsZB8JQv+xUoehmHYbhJSEbcJGgORlFDDAegPggWocBSpmmasEjjYOw57EVf4lYBvSgNxLqQKArSrA+hnODN-jwMItzzchoErFueDDqKpDKDQK0wAJCqMkwM66dxO6gEkealo+-zHYt3RyaYm03jsnirFy5pFBIy1xaa+jYIygQztaRpqMgdCbms+gSPoDkMIs6OY-AvH6AAhMmEJpuVbEiZmLpuhIX0+lEaYZk69M5ozJY8tTdV9F1PUUbcervbt7i4MDg3bvjaxg1SWkCLAtC9kjsa6e4hx8O4726MwEKrLcHHI6aG2WdZ3xIOEthLOQZzjnVlLYLVcLqEi8ACJ6CA7u6tCrJgrmrKF6i6W8OB09mrx+a6n7K44azcZ2gLUmD4g7De2rSD4QA).
+ */
+type IsBounded<T> = (T extends unknown ? Or<IsBoundedString<T>, Or<IsNumericLiteral<T>, IsSymbolLiteral<T>>> : never) extends true ? true : false;
+/**
+ * Literal strings can be unbounded when they are a template literal which
+ * contains non-literal components (e.g. `prefix_${string}`), this is because
+ * there are an infinite number of possible values that satisfy it.
+ */
+type IsBoundedString<T> = T extends string ? IsStringLiteral<T> extends true ? Split<T, ''>[number] extends infer U ? [`${number}`] extends [U] ? false : [string] extends [U] ? false : true : false : false : false;
+//#endregion
+//#region src/internal/types/is-bounded-record.d.ts
+/**
+ * Check if a type is guaranteed to be a bounded record: a record with a finite
+ * set of keys.
+ *
+ * See the docs for `IsBounded` to understand more.
+ *
+ * @example
+ *   IsBoundedRecord<{ a: 1, 1: "a" }>; //=> true
+ *   IsBoundedRecord<Record<string | number, unknown>>; //=> false
+ *   IsBoundedRecord<Record<`prefix_${number}`, unknown>>; //=> false
+ */
+type IsBoundedRecord<T> = IsBounded<KeysOfUnion<T>>;
+//#endregion
+export { IsBounded, IsBoundedRecord };
+//# sourceMappingURL=is-bounded-record-DEQ2a3_Y.d.ts.map

package/dist/is-bounded-record-DEQ2a3_Y.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-bounded-record-DEQ2a3_Y.d.ts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKW,KALC,SAKD,CAAA,CAAA,CAAA,GAAA,CADP,CACO,SAAA,OAAA,GAAH,EAAG,CAAA,eAAA,CAAgB,CAAhB,CAAA,EAAoB,EAApB,CAAuB,gBAAvB,CAAwC,CAAxC,CAAA,EAA4C,eAA5C,CAA4D,CAA5D,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgBN,eAhBG,CAAA,CAAA,CAAA,GAgBkB,CAhBlB,SAAA,MAAA,GAiBJ,eAjBI,CAiBY,CAjBZ,CAAA,SAAA,IAAA,GAmBF,KAnBE,CAmBI,CAnBJ,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBuB,CArBvB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBsB,CAvBtB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALR;;;;;;;;;;AAKQ,KCLI,eDKJ,CAAA,CAAA,CAAA,GCLyB,SDKzB,CCLmC,WDKnC,CCL+C,CDK/C,CAAA,CAAA"}

package/dist/is-date-pSRD0Bm_.d.ts

@@ -0,0 +1,17 @@
+//#region src/is-date.d.ts
+/**
+ * A function that checks if the passed parameter is a Date and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a Date, false otherwise.
+ * @signature
+ *    P.isDate(data)
+ * @example
+ *    P.isDate(new Date()) //=> true
+ *    P.isDate('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isDate(data: unknown): data is Date;
+//#endregion
+export { isDate };
+//# sourceMappingURL=is-date-pSRD0Bm_.d.ts.map

package/dist/is-date-pSRD0Bm_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-date-pSRD0Bm_.d.ts","names":[],"sources":["../src/is-date.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,MAAA,yBAA+B"}

package/dist/is-date.d.ts

@@ -1,2 +1,2 @@
-import { isDate } from "./is-date-BgcZ3-ed.js";
+import { isDate } from "./is-date-pSRD0Bm_.js";
 export { isDate };

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

@@ -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-C5PnLPx2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal-C5PnLPx2.d.ts","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.d.ts

@@ -1,2 +1,2 @@
-import { isDeepEqual } from "./is-deep-equal-B_XN4vCU.js";
+import { isDeepEqual } from "./is-deep-equal-C5PnLPx2.js";
 export { isDeepEqual };

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.d.ts

@@ -1,2 +1,2 @@
-import { isDefined } from "./is-defined-DESIOXqX.js";
+import { isDefined } from "./is-defined-Bjs-PriY.js";
 export { isDefined };

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.d.ts

@@ -1,3 +1,3 @@
-import "./iterable-container-wtkYslN_.js";
-import { isEmpty } from "./is-empty-qOplNC63.js";
+import "./iterable-container-F9CDF7ym.js";
+import { isEmpty } from "./is-empty-DumZFkEX.js";
 export { 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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"}

package/dist/is-emptyish-DTm1VZz9.d.ts

@@ -0,0 +1,74 @@
+import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
+import { NoInfer } from "./no-infer-DmkBZblw.js";
+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-DTm1VZz9.d.ts.map

package/dist/is-emptyish-DTm1VZz9.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-emptyish-DTm1VZz9.d.ts","names":[],"sources":["../src/internal/types/has-writable-keys.ts","../src/is-emptyish.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,qBAIR,QAAQ,SAAS,IAAI;;;cCWX;ADfd,KCsBK,KDtBO,CAAA,CAAA,CAAA,GCsBI,MDtBW,CCsBJ,CDtBI,EAAA,OCsBM,cDtBN,CAAA;KC0BtB,QD1BsB,CAAA,CAAA,CAAA,GAAA,CC4BpB,CD5BoB,SAAA,MAAA,GAAA,EAAA,GAAA,KAAA,CAAA,GAAA,CC6BpB,CD7BoB,SAAA,MAAA,GC6BD,kBD7BC,CC6BkB,CD7BlB,CAAA,GAAA,KAAA,CAAA,GAAA,CC8BpB,CD9BoB,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA,CAAA,GAAA,CC+BpB,CD/BoB,SAAA,SAAA,GAAA,SAAA,GAAA,KAAA,CAAA;KCoCtB,kBDhCgB,CAAA,UAAA,MAAA,CAAA,GCiCjB,CDjCiB,SCiCP,aDjCO,CAAA,OAAA,CAAA,GCkCf,aDlCe,CCkCD,CDlCC,CAAA,GCmCf,CDnCe,SCmCL,WDnCK,CAAA,KAAA,IAAA,EAAA,OAAA,CAAA,GCoCb,CDpCa,SCoCH,GDpCG,CAAA,OAAA,EAAA,OAAA,CAAA,GCsCX,KDtCW,CCsCL,CDtCK,CAAA,GCwCX,WDxCW,CCwCC,GDxCD,EAAA,KAAA,CAAA,GCyCb,CDzCa,SCyCH,WDzCG,CAAA,OAAA,CAAA,GC0CX,CD1CW,SC0CD,GD1CC,CAAA,OAAA,CAAA,GC4CT,KD5CS,CC4CH,CD5CG,CAAA,GC8CT,WD9CS,CAAA,KAAA,CAAA,GC+CX,cD/CW,CC+CI,CD/CJ,CAAA;KCiDhB,aDjDO,CAAA,UCiDiB,aDjDjB,CAAA,OAAA,CAAA,CAAA,GCiD2C,CDjD3C,SAAA,SAAA,EAAA,GCmDR,CDnDQ,GCoDR,GDpDQ,CCqDR,ODrDQ,CCqDA,UDrDA,CCqDW,CDrDX,CAAA,CAAA,UAAA,CAAA,EAAA,EAAA,CAAA,ECsDR,ODtDQ,CCsDA,UDtDA,CCsDW,CDtDX,CAAA,CAAA,QAAA,CAAA,EAAA,EAAA,CAAA,CAAA,SAAA,IAAA,GCwDN,CDxDM,SCwDI,KDxDJ,CAAA,OAAA,CAAA,GC0DJ,KD1DI,CC0DE,CD1DF,CAAA,GAAA,SAAA,EAAA,GAAA,KAAA;KCiEP,cDjEoB,CAAA,UAAA,MAAA,CAAA,GCiEe,CDjEf,SAAA;QAArB,EAAA,KAAA,gBAAA,MAAA;CAAO,GCoEP,CDpEO,SAAA,MAAA,GAAA,KAAA,GC2EL,iBD3EK,CC2Ea,CD3Eb,EC2EgB,MD3EhB,CAAA,GC4EP,CD5EO,SAAA;;IC+EL,kBAAkB,GAAG,QACrB,QAAQ,QAAQ,mBAGd,IACA,gBAAgB,mBAAmB,2BAIjC,gBAAgB,kBAEd,MAAM,4BAEiB,WApF4B;AAGpB,KAsFtC,iBA/EK,CAAA,CAAA,EAAA,CAAA,CAAA,GAgFN,gBAhFM,CAgFW,CAhFX,CAAA,SAAA,IAAA,GAAA,CAAA,CAAA,CAAA,SAAA,CAiFS,CAjFT,CAAA,GAAA,CAkFC,CAlFD,CAAA,SAAA,CAAA,CAAA,CAAA,GAqFI,CArFJ,GAwFI,KAxFJ,CAwFU,CAxFV,CAAA,GAAA,KAAA,GA8FJ,KA9FI,CA8FE,CA9FF,CAAA;KAmGL,eAnGK,CAAA,CAAA,CAAA,GAmGgB,EAnGhB,CAoGR,EApGQ,CAoGL,KApGK,CAoGC,CApGD,CAAA,EAoGK,SApGL,CAoGe,CApGf,CAAA,CAAA,EAqGR,OArGQ,CAsGN,CAtGM,EAAA,CAAA,CAAA,CAAA,CAAA;;;;;AAAY;;;;;;;;;AASd;;;;;;;;;;;;;;;;;;;;;;;;AAoBgB;;;;;;;;;;;;AASlB,iBAuHU,UAvHV,CAAA,CAAA,CAAA,CAAA,IAAA,EAwHE,eAxHF,CAwHkB,CAxHlB,CAAA,SAAA,IAAA,GAAA,KAAA,GA0HA,CA1HA,GA0HI,QA1HJ,CA0Ha,QA1Hb,CA0HsB,OA1HtB,CA0H8B,CA1H9B,CAAA,CAAA,CAAA,CAAA,EAAA,IAAA,IA2HK,eA3HL,CA2HqB,CA3HrB,CAAA,SAAA,IAAA,GAAA,KAAA,GA6HF,CA7HE,SAAA,OAAA,GA8HA,QA9HA,CA8HS,OA9HT,CA8HiB,CA9HjB,CAAA,CAAA,GAAA,KAAA;AAAU,iBAgIA,UAAA,CAhIA,IAAA,EAAA,OAAA,CAAA,EAAA,OAAA"}

package/dist/is-emptyish-EQIjUNpM.js

@@ -0,0 +1,2 @@
+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}export{e as isEmptyish};
+//# sourceMappingURL=is-emptyish-EQIjUNpM.js.map

package/dist/is-emptyish-EQIjUNpM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-emptyish-EQIjUNpM.js","names":[],"sources":["../src/is-emptyish.ts"],"sourcesContent":["import type {\n  And,\n  HasRequiredKeys,\n  IsAny,\n  IsEqual,\n  IsNever,\n  IsNumericLiteral,\n  IsUnknown,\n  OmitIndexSignature,\n  Or,\n  Tagged,\n  ValueOf,\n} from 'type-fest';\nimport type { HasWritableKeys } from './internal/types/has-writable-keys';\nimport type { NoInfer } from './internal/types/no-infer';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n// eslint-disable-next-line ts/no-unused-vars -- we use a non-exported unique symbol to prevent users from faking our return type.\ndeclare const EMPTYISH_BRAND: unique symbol;\n\n// Because our function is a type-predicate and it narrows the input based on\n// the result of our type, we sometimes need a way to \"turn off\" narrowing while\n// still returning the input type. By tagging/branding our return type we stop\n// TypeScript from narrowing it while still allowing it to be used as if it was\n// the input type (because it still extends the type).\ntype Empty<T> = Tagged<T, typeof EMPTYISH_BRAND>;\n\n// The goal of this type is to return the empty \"view\" of the input type. This\n// makes it possible for TypeScript to narrow it precisely.\ntype Emptyish<T>\n  // There are effectively 4 types that can be empty:\n  = | (T extends string ? '' : never)\n    | (T extends object ? EmptyishObjectLike<T> : never)\n    | (T extends null ? null : never)\n    | (T extends undefined ? undefined : never);\n\n// Because of TypeScript's duck-typing, a lot of sub-types of `object` can\n// extend each other so we need to cascade between the different \"kinds\" of\n// objects.\ntype EmptyishObjectLike<T extends object>\n  = T extends ReadonlyArray<unknown>\n    ? EmptyishArray<T>\n    : T extends ReadonlyMap<infer Key, unknown>\n      ? T extends Map<unknown, unknown>\n        // Mutable maps should remain mutable so we can't narrow them down.\n        ? Empty<T>\n        // But immutable maps could be rewritten to prevent any mutations.\n        : ReadonlyMap<Key, never>\n      : T extends ReadonlySet<unknown>\n        ? T extends Set<unknown>\n          // Mutable sets should remain mutable so we can't narrow them down.\n          ? Empty<T>\n          // But immutable sets could be rewritten to prevent any mutations.\n          : ReadonlySet<never>\n        : EmptyishObject<T>;\n\ntype EmptyishArray<T extends ReadonlyArray<unknown>> = T extends readonly []\n  // By returning T we effectively narrow the \"else\" branch to `never`.\n  ? T\n  : And<\n    IsEqual<TupleParts<T>['required'], []>,\n    IsEqual<TupleParts<T>['suffix'], []>\n  > extends true\n    ? T extends Array<unknown>\n      // A mutable array should remain mutable so we can't narrow it down.\n      ? Empty<T>\n      // But immutable arrays could be rewritten to prevent any mutations.\n      : readonly []\n    // An array with a required prefix or suffix would never be empty, we can\n    // use that fact to narrow the \"if\" branch to `never`.\n    : never;\n\ntype EmptyishObject<T extends object> = T extends {\n  length: infer Length extends number;\n}\n  ? T extends string\n    // When a string is tagged/branded it also extends `object` and also has\n    // a `length` prop so we need to prevent handling it because it's\n    // irrelevant here!\n    ? never\n    // Because of how the implementation works, we need to consider any object\n    // with a `length` prop as potentially \"empty\".\n    : EmptyishArbitrary<T, Length>\n  : T extends { size: infer Size extends number }\n    // Because of how the implementation works, we need to consider any object\n    // with a `size` prop as potentially \"empty\".\n    ? EmptyishArbitrary<T, Size>\n    : IsNever<ValueOf<T>> extends true\n      // This handles empty objects; by returning T we effectively narrow the\n      // \"else\" branch to `never`.\n      ? T\n      : HasRequiredKeys<OmitIndexSignature<T>> extends true\n        // If the object has required keys it can never be empty, we can use\n        // that fact to narrow the \"if\" branch to `never`.\n        ? never\n        : HasWritableKeys<T> extends true\n          // A mutable object should remain mutable so we can't narrow it down.\n          ? Empty<T>\n          // But immutable objects could be rewritten to prevent any mutations.\n          : { readonly [P in keyof T]: never };\n\n// We use certain props to check for emptiness effectively, but that means we\n// will return those values for any object that has them. Because we don't know\n// anything about those objects we need to be careful about narrowing.\ntype EmptyishArbitrary<T, N>\n  = IsNumericLiteral<N> extends true\n    ? [0] extends [N]\n        ? [N] extends [0]\n            // If the prop is a literal 0 the object is and always will be empty\n            // so we can return it to narrow the \"else\" branch as `never`.\n            ? T\n            // If it accepts 0, but might accept other values too we need to\n            // consider the object mutable and not narrow it down.\n            : Empty<T>\n        // If the prop will never be 0 we can say it will never be empty and can\n        // return `never` for the \"if\" branch.\n        : never\n    // If the prop isn't a literal value we don't know enough about the object\n    // and should consider it mutable.\n    : Empty<T>;\n\n// Overly generic types interfere with our already pretty complex return type.\n// To make our lives easier we can filter them out at the function declaration\n// step and we never need to think about them again.\ntype ShouldNotNarrow<T> = Or<\n  Or<IsAny<T>, IsUnknown<T>>,\n  IsEqual<\n    T,\n    // eslint-disable-next-line ts/no-empty-object-type\n    {}\n  >\n>;\n\n/**\n * A function that checks if the input is empty. Empty is defined as anything\n * exposing a numerical `length`, or `size` property that is equal to `0`. This\n * definition covers strings, arrays, Maps, Sets, plain objects, and custom\n * classes. Additionally, `null` and `undefined` are also considered empty.\n *\n * `number`, `bigint`, `boolean`, `symbol`, and `function` will always return\n * `false`. `RegExp`, `Date`, and weak collections will always return `true`.\n * Classes and Errors are treated as plain objects: if they expose any public\n * property they would be considered non-empty, unless they expose a numerical\n * `length` or `size` property, which defines their emptiness regardless of\n * other properties.\n *\n * This function has *limited* utility at the type level because **negating** it\n * does not yield a useful type in most cases because of TypeScript\n * limitations. Additionally, utilities which accept a narrower input type\n * provide better type-safety on their inputs. In most cases, you should use\n * one of the following functions instead:\n * `isEmpty` - provides better type-safety on inputs by accepting a narrower set of cases.\n * `hasAtLeast` - when the input is just an array/tuple.\n * `isStrictEqual` - when you just need to check for a specific literal value.\n * `isNullish` - when you just care about `null` and `undefined`.\n * `isTruthy` - when you need to also filter `number` and `boolean`.\n *\n * @param data - The variable to check.\n * @signature\n *    P.isEmptyish(data)\n * @example\n *    P.isEmptyish(undefined); //=> true\n *    P.isEmptyish(null); //=> true\n *    P.isEmptyish(''); //=> true\n *    P.isEmptyish([]); //=> true\n *    P.isEmptyish({}); //=> true\n *    P.isEmptyish(new Map()); //=> true\n *    P.isEmptyish(new Set()); //=> true\n *    P.isEmptyish({ a: \"hello\", size: 0 }); //=> true\n *    P.isEmptyish(/abc/); //=> true\n *    P.isEmptyish(new Date()); //=> true\n *    P.isEmptyish(new WeakMap()); //=> true\n *\n *    P.isEmptyish('test'); //=> false\n *    P.isEmptyish([1, 2, 3]); //=> false\n *    P.isEmptyish({ a: \"hello\" }); //=> false\n *    P.isEmptyish({ length: 1 }); //=> false\n *    P.isEmptyish(0); //=> false\n *    P.isEmptyish(true); //=> false\n *    P.isEmptyish(() => {}); //=> false\n * @category Guard\n */\nexport function isEmptyish<T>(\n  data: ShouldNotNarrow<T> extends true\n    ? never\n    : T | Readonly<Emptyish<NoInfer<T>>>,\n): data is ShouldNotNarrow<T> extends true\n  ? never\n  : T extends unknown\n    ? Emptyish<NoInfer<T>>\n    : never;\nexport function isEmptyish(data: unknown): boolean;\n\nexport function isEmptyish(data: unknown): boolean {\n  // eslint-disable-next-line eqeqeq -- Less code to ship.\n  if (data == undefined || data === '') {\n    // These are the only literal values that are considered emptyish.\n    return true;\n  }\n\n  if (typeof data !== 'object') {\n    // There are no non-object types that could be empty at this point...\n    return false;\n  }\n\n  if ('length' in data && typeof data.length === 'number') {\n    // Arrays and array-likes.\n    return data.length === 0;\n  }\n\n  if ('size' in data && typeof data.size === 'number') {\n    // Maps and Sets.\n    return data.size === 0;\n  }\n\n  // eslint-disable-next-line no-unreachable-loop, no-restricted-syntax -- Instead of taking Object.keys just to check its length, which will be inefficient if the object has a lot of keys, we have a backdoor into an iterator of the object's properties via the `for...in` loop.\n  for (const _ in data) {\n    return false;\n  }\n\n  // We can't do a similar optimization for symbol props, so we leave them for\n  // the very last check when the object is practically empty. Assuming that\n  // even if an object has a symbol prop, it probably doesn't have thousands of\n  // them.\n  return Object.getOwnPropertySymbols(data).length === 0;\n}\n"],"mappings":"AAiMA,SAAgB,EAAW,EAAwB,CAEjD,GAAI,GAAQ,MAAa,IAAS,GAEhC,MAAO,GAGT,GAAI,OAAO,GAAS,SAElB,MAAO,GAGT,GAAI,WAAY,GAAQ,OAAO,EAAK,QAAW,SAE7C,OAAO,EAAK,SAAW,EAGzB,GAAI,SAAU,GAAQ,OAAO,EAAK,MAAS,SAEzC,OAAO,EAAK,OAAS,EAIvB,IAAK,IAAM,KAAK,EACd,MAAO,GAOT,OAAO,OAAO,sBAAsB,EAAK,CAAC,SAAW"}

package/dist/is-emptyish.cjs

@@ -0,0 +1 @@
+const e=require(`./is-emptyish-CtpYRY75.cjs`);exports.isEmptyish=e.isEmptyish;

package/dist/is-emptyish.d.cts

@@ -0,0 +1,6 @@
+import "./iterable-container-V5sa0V_H.cjs";
+import "./perkakas-type-error-0tHtaPbi.cjs";
+import "./tuple-parts-BIyABPYv.cjs";
+import { isEmptyish } from "./is-emptyish-DAVU8RH1.cjs";
+import "./no-infer-CFhWzPzc.cjs";
+export { isEmptyish };

package/dist/is-emptyish.d.ts

@@ -0,0 +1,6 @@
+import "./iterable-container-F9CDF7ym.js";
+import "./perkakas-type-error-2yBU0Drj.js";
+import "./tuple-parts-Du2iVN8H.js";
+import { isEmptyish } from "./is-emptyish-DTm1VZz9.js";
+import "./no-infer-DmkBZblw.js";
+export { isEmptyish };

package/dist/is-emptyish.js

@@ -0,0 +1 @@
+import{isEmptyish as e}from"./is-emptyish-EQIjUNpM.js";export{e as isEmptyish};