@vinicunca/perkakas 0.5.3 → 1.0.0

package/dist/is-empty.d.cts

@@ -0,0 +1,33 @@
+import { I as IterableContainer } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * 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 Readonly<Record<PropertyKey, unknown>>>(data: T): data is Record<keyof T, never>;
+
+export { isEmpty };

package/dist/is-empty.d.ts

@@ -0,0 +1,33 @@
+import { I as IterableContainer } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * 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 Readonly<Record<PropertyKey, unknown>>>(data: T): data is Record<keyof T, never>;
+
+export { isEmpty };

package/dist/is-empty.js

@@ -0,0 +1 @@
+import{a}from"./chunk-ZW3IUWYO.js";export{a as isEmpty};

package/dist/is-error.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHL3QPU5Jcjs = require('./chunk-HL3QPU5J.cjs');exports.isError = _chunkHL3QPU5Jcjs.a;

package/dist/is-error.d.cts

@@ -0,0 +1,16 @@
+type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, Error>;
+/**
+ * A function that checks if the passed parameter is an Error and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is an Error, false otherwise.
+ * @signature
+ *    P.isError(data)
+ * @example
+ *    P.isError(new Error('message')) //=> true
+ *    P.isError('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isError<T>(data: Error | T): data is DefinitelyError<T>;
+
+export { isError };

package/dist/is-error.d.ts

@@ -0,0 +1,16 @@
+type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, Error>;
+/**
+ * A function that checks if the passed parameter is an Error and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is an Error, false otherwise.
+ * @signature
+ *    P.isError(data)
+ * @example
+ *    P.isError(new Error('message')) //=> true
+ *    P.isError('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isError<T>(data: Error | T): data is DefinitelyError<T>;
+
+export { isError };

package/dist/is-error.js

@@ -0,0 +1 @@
+import{a}from"./chunk-7EMQYM4A.js";export{a as isError};

package/dist/is-function.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkZCCHYKDGcjs = require('./chunk-ZCCHYKDG.cjs');exports.isFunction = _chunkZCCHYKDGcjs.a;

package/dist/is-function.d.cts

@@ -0,0 +1,16 @@
+type DefinitelyFunction<T> = Extract<T, Function> extends never ? Function : Extract<T, Function>;
+/**
+ * A function that checks if the passed parameter is a Function and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a Function, false otherwise.
+ * @signature
+ *    P.isFunction(data)
+ * @example
+ *    P.isFunction(() => {}) //=> true
+ *    P.isFunction('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isFunction<T>(data: Function | T): data is DefinitelyFunction<T>;
+
+export { isFunction };

package/dist/is-function.d.ts

@@ -0,0 +1,16 @@
+type DefinitelyFunction<T> = Extract<T, Function> extends never ? Function : Extract<T, Function>;
+/**
+ * A function that checks if the passed parameter is a Function and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a Function, false otherwise.
+ * @signature
+ *    P.isFunction(data)
+ * @example
+ *    P.isFunction(() => {}) //=> true
+ *    P.isFunction('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isFunction<T>(data: Function | T): data is DefinitelyFunction<T>;
+
+export { isFunction };

package/dist/is-function.js

@@ -0,0 +1 @@
+import{a}from"./chunk-VPHS3T3W.js";export{a as isFunction};

package/dist/is-included-in.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkWFR3HBYRcjs = require('./chunk-WFR3HBYR.cjs');exports.isIncludedIn = _chunkWFR3HBYRcjs.a;

package/dist/is-included-in.d.cts

@@ -0,0 +1,106 @@
+import { IsLiteral } from 'type-fest';
+import { I as IterableContainer, d as IsUnion } from './types-DCY4LHuA.cjs';
+
+/**
+ * A "constant" tuple is a type that has a single runtime value that can fulfil
+ * it. This means that it doesn't have any variadic/rest/spread/array parts, and
+ * that all it's values are singular (non-union) literals.
+ *
+ * We use this type to allow narrowing when checking against a set of values
+ * defined as a const.
+ *
+ * @example
+ *   type T1 = IsConstantTuple<["cat", "dog", 3, true]>; // => true;
+ *   type T2 = IsConstantTuple<["cat" | "dog"]>; // false;
+ *   type T2 = IsConstantTuple<["cat", ...Array<"cat">]>; // false;
+ */
+type IsConstantTuple<T extends IterableContainer> = T extends readonly [] ? true : T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? false : IsConstantTuple<Rest> : false;
+/**
+ * There is no way to tell Typescript to only narrow the "accepted" side of a
+ * type-predicate and so in many cases the negated side is also affected, this
+ * results in over-narrowing in many cases, breaking typing. For this reason we
+ * only want to use the type-predicate variant of `isIncludedIn` when we can
+ * assume the result represents the expected types (closely enough). This is not
+ * and ideal solution and we will still generate wrong types in some cases (see
+ * tests), but it reduces the surface of this problem significantly, while still
+ * keeping the utility of `isIncludedIn` for the common cases.
+ *
+ * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or
+ * when T isn't a literal, but S is.
+ *
+ * @example
+ *   const data = 1 as 1 | 2 | 3;
+ *   const container = [] as Array<1 | 2>;
+ *   if (isIncludedIn(data, container)) {
+ *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part
+ *     ... of the typing of container, so will never result in being true.
+ *   } else {
+ *     ... but it doesn't make sense to narrow the value to 3 here, because 1
+ *     ... and 2 are still valid values for data, when container doesn't include
+ *     ... them **at runtime**.
+ *     ... Typescript narrows the _rejected_ branch based on how it narrowed the
+ *     ... _accepted_ clause, and we can't control that; because our input type
+ *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is
+ *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.
+ *   }
+ * }
+ */
+type IsNarrowable<T, S extends IterableContainer<T>> = IsLiteral<T> extends true ? IsConstantTuple<S> : IsLiteral<S[number]>;
+/**
+ * Checks if the item is included in the container. This is a wrapper around
+ * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the
+ * same equality checks that those functions do (which is reference equality,
+ * e.g. `===`). In some cases the input's type is also narrowed to the
+ * container's item types.
+ *
+ * Notice that unlike most functions, this function takes a generic item as it's
+ * data and **an array** as it's parameter.
+ *
+ * @param data - The item that is checked.
+ * @param container - The items that are checked against.
+ * @returns `true` if the item is in the container, or `false` otherwise. In
+ * cases the type of `data` is also narrowed down.
+ * @signature
+ *   P.isIncludedIn(data, container);
+ * @example
+ *   P.isIncludedIn(2, [1, 2, 3]); // => true
+ *   P.isIncludedIn(4, [1, 2, 3]); // => false
+ *
+ *   const data = "cat" as "cat" | "dog" | "mouse";
+ *   P.isIncludedIn(data, ["cat", "dog"] as const); // true (typed "cat" | "dog");
+ * @dataFirst
+ * @category Guard
+ */
+declare function isIncludedIn<T, S extends IterableContainer<T>>(data: T, container: IsNarrowable<T, S> extends true ? S : never): data is S[number];
+declare function isIncludedIn<T, S extends T>(data: T, container: IterableContainer<S>): boolean;
+/**
+ * Checks if the item is included in the container. This is a wrapper around
+ * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the
+ * same equality checks that those functions do (which is reference equality,
+ * e.g. `===`). In some cases the input's type is also narrowed to the
+ * container's item types.
+ *
+ * Notice that unlike most functions, this function takes a generic item as it's
+ * data and **an array** as it's parameter.
+ *
+ * @param container - The items that are checked against.
+ * @returns `true` if the item is in the container, or `false` otherwise. In
+ * cases the type of `data` is also narrowed down.
+ * @signature
+ *   P.isIncludedIn(container)(data);
+ * @example
+ *   P.pipe(2, P.isIncludedIn([1, 2, 3])); // => true
+ *   P.pipe(4, P.isIncludedIn([1, 2, 3])); // => false
+ *
+ *   const data = "cat" as "cat" | "dog" | "mouse";
+ *   P.pipe(
+ *     data,
+ *     P.isIncludedIn(["cat", "dog"] as const),
+ *   ); // => true (typed "cat" | "dog");
+ * @dataLast
+ * @category Guard
+ */
+declare function isIncludedIn<T, S extends IterableContainer<T>>(container: IsNarrowable<T, S> extends true ? S : never): (data: T) => data is S[number];
+declare function isIncludedIn<T, S extends T>(container: IterableContainer<S>): (data: T) => boolean;
+
+export { isIncludedIn };

package/dist/is-included-in.d.ts

@@ -0,0 +1,106 @@
+import { IsLiteral } from 'type-fest';
+import { I as IterableContainer, d as IsUnion } from './types-DCY4LHuA.js';
+
+/**
+ * A "constant" tuple is a type that has a single runtime value that can fulfil
+ * it. This means that it doesn't have any variadic/rest/spread/array parts, and
+ * that all it's values are singular (non-union) literals.
+ *
+ * We use this type to allow narrowing when checking against a set of values
+ * defined as a const.
+ *
+ * @example
+ *   type T1 = IsConstantTuple<["cat", "dog", 3, true]>; // => true;
+ *   type T2 = IsConstantTuple<["cat" | "dog"]>; // false;
+ *   type T2 = IsConstantTuple<["cat", ...Array<"cat">]>; // false;
+ */
+type IsConstantTuple<T extends IterableContainer> = T extends readonly [] ? true : T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? false : IsConstantTuple<Rest> : false;
+/**
+ * There is no way to tell Typescript to only narrow the "accepted" side of a
+ * type-predicate and so in many cases the negated side is also affected, this
+ * results in over-narrowing in many cases, breaking typing. For this reason we
+ * only want to use the type-predicate variant of `isIncludedIn` when we can
+ * assume the result represents the expected types (closely enough). This is not
+ * and ideal solution and we will still generate wrong types in some cases (see
+ * tests), but it reduces the surface of this problem significantly, while still
+ * keeping the utility of `isIncludedIn` for the common cases.
+ *
+ * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or
+ * when T isn't a literal, but S is.
+ *
+ * @example
+ *   const data = 1 as 1 | 2 | 3;
+ *   const container = [] as Array<1 | 2>;
+ *   if (isIncludedIn(data, container)) {
+ *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part
+ *     ... of the typing of container, so will never result in being true.
+ *   } else {
+ *     ... but it doesn't make sense to narrow the value to 3 here, because 1
+ *     ... and 2 are still valid values for data, when container doesn't include
+ *     ... them **at runtime**.
+ *     ... Typescript narrows the _rejected_ branch based on how it narrowed the
+ *     ... _accepted_ clause, and we can't control that; because our input type
+ *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is
+ *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.
+ *   }
+ * }
+ */
+type IsNarrowable<T, S extends IterableContainer<T>> = IsLiteral<T> extends true ? IsConstantTuple<S> : IsLiteral<S[number]>;
+/**
+ * Checks if the item is included in the container. This is a wrapper around
+ * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the
+ * same equality checks that those functions do (which is reference equality,
+ * e.g. `===`). In some cases the input's type is also narrowed to the
+ * container's item types.
+ *
+ * Notice that unlike most functions, this function takes a generic item as it's
+ * data and **an array** as it's parameter.
+ *
+ * @param data - The item that is checked.
+ * @param container - The items that are checked against.
+ * @returns `true` if the item is in the container, or `false` otherwise. In
+ * cases the type of `data` is also narrowed down.
+ * @signature
+ *   P.isIncludedIn(data, container);
+ * @example
+ *   P.isIncludedIn(2, [1, 2, 3]); // => true
+ *   P.isIncludedIn(4, [1, 2, 3]); // => false
+ *
+ *   const data = "cat" as "cat" | "dog" | "mouse";
+ *   P.isIncludedIn(data, ["cat", "dog"] as const); // true (typed "cat" | "dog");
+ * @dataFirst
+ * @category Guard
+ */
+declare function isIncludedIn<T, S extends IterableContainer<T>>(data: T, container: IsNarrowable<T, S> extends true ? S : never): data is S[number];
+declare function isIncludedIn<T, S extends T>(data: T, container: IterableContainer<S>): boolean;
+/**
+ * Checks if the item is included in the container. This is a wrapper around
+ * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the
+ * same equality checks that those functions do (which is reference equality,
+ * e.g. `===`). In some cases the input's type is also narrowed to the
+ * container's item types.
+ *
+ * Notice that unlike most functions, this function takes a generic item as it's
+ * data and **an array** as it's parameter.
+ *
+ * @param container - The items that are checked against.
+ * @returns `true` if the item is in the container, or `false` otherwise. In
+ * cases the type of `data` is also narrowed down.
+ * @signature
+ *   P.isIncludedIn(container)(data);
+ * @example
+ *   P.pipe(2, P.isIncludedIn([1, 2, 3])); // => true
+ *   P.pipe(4, P.isIncludedIn([1, 2, 3])); // => false
+ *
+ *   const data = "cat" as "cat" | "dog" | "mouse";
+ *   P.pipe(
+ *     data,
+ *     P.isIncludedIn(["cat", "dog"] as const),
+ *   ); // => true (typed "cat" | "dog");
+ * @dataLast
+ * @category Guard
+ */
+declare function isIncludedIn<T, S extends IterableContainer<T>>(container: IsNarrowable<T, S> extends true ? S : never): (data: T) => data is S[number];
+declare function isIncludedIn<T, S extends T>(container: IterableContainer<S>): (data: T) => boolean;
+
+export { isIncludedIn };

package/dist/is-included-in.js

@@ -0,0 +1 @@
+import{a}from"./chunk-75K2QEB3.js";export{a as isIncludedIn};

package/dist/is-non-null.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk7XMQFPW7cjs = require('./chunk-7XMQFPW7.cjs');exports.isNonNull = _chunk7XMQFPW7cjs.a;

package/dist/is-non-null.d.cts

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

package/dist/is-non-null.d.ts

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

package/dist/is-non-null.js

@@ -0,0 +1 @@
+import{a}from"./chunk-6BKLAQWR.js";export{a as isNonNull};

package/dist/is-non-nullish.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkDAFN5EJRcjs = require('./chunk-DAFN5EJR.cjs');exports.isNonNullish = _chunkDAFN5EJRcjs.a;

package/dist/is-non-nullish.d.cts

@@ -0,0 +1,18 @@
+/**
+ * A function that checks if the passed parameter is defined *AND* isn't `null`
+ * and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is defined and isn't `null`, false
+ * otherwise.
+ * @signature
+ *    P.isNonNullish(data)
+ * @example
+ *    P.isNonNullish('string') //=> true
+ *    P.isNonNullish(null) //=> false
+ *    P.isNonNullish(undefined) //=> false
+ * @category Guard
+ */
+declare function isNonNullish<T>(data: T): data is NonNullable<T>;
+
+export { isNonNullish };

package/dist/is-non-nullish.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A function that checks if the passed parameter is defined *AND* isn't `null`
+ * and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is defined and isn't `null`, false
+ * otherwise.
+ * @signature
+ *    P.isNonNullish(data)
+ * @example
+ *    P.isNonNullish('string') //=> true
+ *    P.isNonNullish(null) //=> false
+ *    P.isNonNullish(undefined) //=> false
+ * @category Guard
+ */
+declare function isNonNullish<T>(data: T): data is NonNullable<T>;
+
+export { isNonNullish };

package/dist/is-non-nullish.js

@@ -0,0 +1 @@
+import{a}from"./chunk-QPP664N4.js";export{a as isNonNullish};

package/dist/is-not.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkU3OEHN5Pcjs = require('./chunk-U3OEHN5P.cjs');exports.isNot = _chunkU3OEHN5Pcjs.a;

package/dist/is-not.d.cts

@@ -0,0 +1,17 @@
+/**
+ * A function that takes a guard function as predicate and returns a guard that negates it.
+ *
+ * @param predicate - The guard function to negate.
+ * @returns Function A guard function.
+ * @signature
+ *    P.isNot(P.isTruthy)(data)
+ * @example
+ *    P.isNot(P.isTruthy)(false) //=> true
+ *    P.isNot(P.isTruthy)(true) //=> false
+ * @dataLast
+ * @category Guard
+ */
+declare function isNot<T, S extends T>(predicate: (data: T) => data is S): (data: T) => data is Exclude<T, S>;
+declare function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;
+
+export { isNot };

package/dist/is-not.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A function that takes a guard function as predicate and returns a guard that negates it.
+ *
+ * @param predicate - The guard function to negate.
+ * @returns Function A guard function.
+ * @signature
+ *    P.isNot(P.isTruthy)(data)
+ * @example
+ *    P.isNot(P.isTruthy)(false) //=> true
+ *    P.isNot(P.isTruthy)(true) //=> false
+ * @dataLast
+ * @category Guard
+ */
+declare function isNot<T, S extends T>(predicate: (data: T) => data is S): (data: T) => data is Exclude<T, S>;
+declare function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;
+
+export { isNot };

package/dist/is-not.js

@@ -0,0 +1 @@
+import{a}from"./chunk-G73S4IVJ.js";export{a as isNot};

package/dist/is-nullish.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkXUEOOIR6cjs = require('./chunk-XUEOOIR6.cjs');exports.isNullish = _chunkXUEOOIR6cjs.a;

package/dist/is-nullish.d.cts

@@ -0,0 +1,21 @@
+import { c as NarrowedTo } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * A function that checks if the passed parameter is either `null` or
+ * `undefined` and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is either `null` or `undefined`, false
+ * otherwise.
+ * @signature
+ *    P.isNullish(data)
+ * @example
+ *    P.isNullish(undefined) //=> true
+ *    P.isNullish(null) //=> true
+ *    P.isNullish('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isNullish<T>(data: T | null | undefined): data is NarrowedTo<T, null | undefined>;
+
+export { isNullish };

package/dist/is-nullish.d.ts

@@ -0,0 +1,21 @@
+import { c as NarrowedTo } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * A function that checks if the passed parameter is either `null` or
+ * `undefined` and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is either `null` or `undefined`, false
+ * otherwise.
+ * @signature
+ *    P.isNullish(data)
+ * @example
+ *    P.isNullish(undefined) //=> true
+ *    P.isNullish(null) //=> true
+ *    P.isNullish('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isNullish<T>(data: T | null | undefined): data is NarrowedTo<T, null | undefined>;
+
+export { isNullish };

package/dist/is-nullish.js

@@ -0,0 +1 @@
+import{a}from"./chunk-TBXEXWSK.js";export{a as isNullish};

package/dist/is-number.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYWTY4X2Rcjs = require('./chunk-YWTY4X2R.cjs');exports.isNumber = _chunkYWTY4X2Rcjs.a;

package/dist/is-number.d.cts

@@ -0,0 +1,20 @@
+import { c as NarrowedTo } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * A function that checks if the passed parameter is a number and narrows its
+ * type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a number, false otherwise.
+ * @signature
+ *    P.isNumber(data)
+ * @example
+ *    P.isNumber(1); // => true
+ *    P.isNumber(1n); // => false
+ *    P.isNumber('notANumber'); // => false
+ * @category Guard
+ */
+declare function isNumber<T>(data: T | number): data is NarrowedTo<T, number>;
+
+export { isNumber };

package/dist/is-number.d.ts

@@ -0,0 +1,20 @@
+import { c as NarrowedTo } from './types-DCY4LHuA.js';
+import 'type-fest';
+
+/**
+ * A function that checks if the passed parameter is a number and narrows its
+ * type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a number, false otherwise.
+ * @signature
+ *    P.isNumber(data)
+ * @example
+ *    P.isNumber(1); // => true
+ *    P.isNumber(1n); // => false
+ *    P.isNumber('notANumber'); // => false
+ * @category Guard
+ */
+declare function isNumber<T>(data: T | number): data is NarrowedTo<T, number>;
+
+export { isNumber };

package/dist/is-number.js

@@ -0,0 +1 @@
+import{a}from"./chunk-Q2HW4RVT.js";export{a as isNumber};

package/dist/is-object-type.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVD6VNORFcjs = require('./chunk-VD6VNORF.cjs');exports.isObjectType = _chunkVD6VNORFcjs.a;

package/dist/is-object-type.d.cts

@@ -0,0 +1,31 @@
+import { c as NarrowedTo } from './types-DCY4LHuA.cjs';
+import 'type-fest';
+
+/**
+ * Checks if the given parameter is of type `"object"` via `typeof`, excluding `null`.
+ *
+ * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more. Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.
+ *
+ * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead. For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.
+ *
+ * @param data - The variable to be checked for being an object type.
+ * @returns The input type, narrowed to only objects.
+ * @signature
+ *    P.isObjectType(data)
+ * @example
+ *    // true
+ *    P.isObjectType({}) //=> true
+ *    P.isObjectType([]) //=> true
+ *    P.isObjectType(Promise.resolve("something")) //=> true
+ *    P.isObjectType(new Date()) //=> true
+ *    P.isObjectType(new Error("error")) //=> true
+ *
+ *    // false
+ *    P.isObjectType('somethingElse') //=> false
+ *    P.isObjectType(null) //=> false
+ * @dataFirst
+ * @category Guard
+ */
+declare const isObjectType: <T>(data: T | object) => data is NarrowedTo<T, object>;
+
+export { isObjectType };