@vinicunca/perkakas 1.13.2 → 1.14.0

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

@@ -1,35 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.cjs";
-
-//#region src/is-object-type.d.ts
-
-/**
- * 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 function isObjectType<T>(data: object | T): data is NarrowedTo<T, object>;
-//#endregion
-export { isObjectType };
-//# sourceMappingURL=is-object-type.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-object-type.d.cts","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":[],"mappings":";;;;;;AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,+BACC,YACN,WAAW"}

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

@@ -1,35 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.js";
-
-//#region src/is-object-type.d.ts
-
-/**
- * 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 function isObjectType<T>(data: object | T): data is NarrowedTo<T, object>;
-//#endregion
-export { isObjectType };
-//# sourceMappingURL=is-object-type.d.ts.map

package/dist/is-object-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-object-type.d.ts","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":[],"mappings":";;;;;;AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,+BACC,YACN,WAAW"}

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

@@ -1,33 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.cjs";
-
-//#region src/is-plain-object.d.ts
-
-/**
- * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
- *
- * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
- *
- * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
- *
- * @param data - The variable to check.
- * @returns The input type, narrowed to only plain objects.
- * @signature
- *    P.isPlainObject(data)
- * @example
- *    // true
- *    P.isPlainObject({}) //=> true
- *    P.isPlainObject({ a: 123 }) //=> true
- *
- *    // false
- *    P.isPlainObject([]) //=> false
- *    P.isPlainObject(Promise.resolve("something")) //=> false
- *    P.isPlainObject(new Date()) //=> false
- *    P.isPlainObject(new Error("error")) //=> false
- *    P.isPlainObject('somethingElse') //=> false
- *    P.isPlainObject(null) //=> false
- * @category Guard
- */
-declare function isPlainObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
-//#endregion
-export { isPlainObject };
-//# sourceMappingURL=is-plain-object.d.cts.map

package/dist/is-plain-object.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object.d.cts","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,uBACR,SAAS,OAAO,yBAAyB,YACtC,WAAW,GAAG,OAAO"}

package/dist/is-plain-object.d.ts

@@ -1,33 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.js";
-
-//#region src/is-plain-object.d.ts
-
-/**
- * Checks if `data` is a "plain" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.
- *
- * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `"object"` by JavaScript's `typeof`.
- *
- * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.
- *
- * @param data - The variable to check.
- * @returns The input type, narrowed to only plain objects.
- * @signature
- *    P.isPlainObject(data)
- * @example
- *    // true
- *    P.isPlainObject({}) //=> true
- *    P.isPlainObject({ a: 123 }) //=> true
- *
- *    // false
- *    P.isPlainObject([]) //=> false
- *    P.isPlainObject(Promise.resolve("something")) //=> false
- *    P.isPlainObject(new Date()) //=> false
- *    P.isPlainObject(new Error("error")) //=> false
- *    P.isPlainObject('somethingElse') //=> false
- *    P.isPlainObject(null) //=> false
- * @category Guard
- */
-declare function isPlainObject<T>(data: Readonly<Record<PropertyKey, unknown>> | T): data is NarrowedTo<T, Record<PropertyKey, unknown>>;
-//#endregion
-export { isPlainObject };
-//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/is-plain-object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object.d.ts","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,uBACR,SAAS,OAAO,yBAAyB,YACtC,WAAW,GAAG,OAAO"}

package/dist/is-promise.d.cts

@@ -1,18 +0,0 @@
-//#region src/is-promise.d.ts
-/**
- * A function that checks if the passed parameter is a Promise and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is a Promise, false otherwise.
- * @signature
- *    P.isPromise(data)
- * @example
- *    P.isPromise(Promise.resolve(5)) //=> true
- *    P.isPromise(Promise.reject(5)) //=> true
- *    P.isPromise('somethingElse') //=> false
- * @category Guard
- */
-declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
-//#endregion
-export { isPromise };
-//# sourceMappingURL=is-promise.d.cts.map

package/dist/is-promise.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-promise.d.cts","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;;;;iBAAgB,sBAAsB,QAAQ,KAAK,YAAY,QAAQ"}

package/dist/is-promise.d.ts

@@ -1,18 +0,0 @@
-//#region src/is-promise.d.ts
-/**
- * A function that checks if the passed parameter is a Promise and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is a Promise, false otherwise.
- * @signature
- *    P.isPromise(data)
- * @example
- *    P.isPromise(Promise.resolve(5)) //=> true
- *    P.isPromise(Promise.reject(5)) //=> true
- *    P.isPromise('somethingElse') //=> false
- * @category Guard
- */
-declare function isPromise<T, S>(data: Promise<T> | S): data is Promise<T>;
-//#endregion
-export { isPromise };
-//# sourceMappingURL=is-promise.d.ts.map

package/dist/is-promise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-promise.d.ts","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;;;;iBAAgB,sBAAsB,QAAQ,KAAK,YAAY,QAAQ"}

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

@@ -1,71 +0,0 @@
-//#region src/is-shallow-equal.d.ts
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
- * are semantically different (e.g. resolved promises); but `isDeepEqual` does
- * compare the latter 2 semantically by-value.
- *
- * 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.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param data - The first value to compare.
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(data, other)
- * @example
- *    P.isShallowEqual(1, 1) //=> true
- *    P.isShallowEqual(1, '1') //=> false
- *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
- *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
- * even when they are semantically different (e.g. resolved promises). Use
- * `isDeepEqual` instead.
- *
- * 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.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(other)(data)
- * @example
- *    P.pipe(1, P.isShallowEqual(1)) //=> true
- *    P.pipe(1, P.isShallowEqual('1')) //=> false
- *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
- *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
-//#endregion
-export { isShallowEqual };
-//# sourceMappingURL=is-shallow-equal.d.cts.map

package/dist/is-shallow-equal.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-shallow-equal.d.cts","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;AAIA;;;;;;AAiCA;;;;;;;;;;AAGA;;;;;AAE4B,iBA1CZ,cA0CY,CAAA,CAAA,EAAA,UA1CgB,CA0ChB,CAAA,CAAA,IAAA,EAzCpB,CAyCoB,EAAA,KAAA,EAxCnB,CAwCmB,SAxCT,OAwCS,CAxCD,CAwCC,EAxCE,CAwCF,CAAA,GAxCO,CAwCP,GAAA,KAAA,CAAA,EAAA,IAAA,IAvCjB,CAuCiB;iBAtCZ,4BAA4B,IAAI,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnD,4BAA4B,UACnC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,yBACP,eACK,IAAI,SAAS"}

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

@@ -1,71 +0,0 @@
-//#region src/is-shallow-equal.d.ts
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they
- * are semantically different (e.g. resolved promises); but `isDeepEqual` does
- * compare the latter 2 semantically by-value.
- *
- * 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.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param data - The first value to compare.
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(data, other)
- * @example
- *    P.isShallowEqual(1, 1) //=> true
- *    P.isShallowEqual(1, '1') //=> false
- *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true
- *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;
-/**
- * Performs a *shallow structural* comparison between two values to determine if
- * they are equivalent. For primitive values this is equivalent to `===`, for
- * arrays a **strict equality** check would be performed on every item, in
- * order, and for objects props will be matched and checked for **strict
- * equality**; Unlike `isDeepEqual` where the function also *recurses* into each
- * item and value.
- *
- * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,
- * even when they are semantically different (e.g. resolved promises). Use
- * `isDeepEqual` instead.
- *
- * 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.
- * - `isDeepEqual` for a recursively deep check of arrays and objects.
- *
- * @param other - The second value to compare.
- * @signature
- *    P.isShallowEqual(other)(data)
- * @example
- *    P.pipe(1, P.isShallowEqual(1)) //=> true
- *    P.pipe(1, P.isShallowEqual('1')) //=> false
- *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true
- *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isShallowEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isShallowEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
-//#endregion
-export { isShallowEqual };
-//# sourceMappingURL=is-shallow-equal.d.ts.map

package/dist/is-shallow-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-shallow-equal.d.ts","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;AAIA;;;;;;AAiCA;;;;;;;;;;AAGA;;;;;AAE4B,iBA1CZ,cA0CY,CAAA,CAAA,EAAA,UA1CgB,CA0ChB,CAAA,CAAA,IAAA,EAzCpB,CAyCoB,EAAA,KAAA,EAxCnB,CAwCmB,SAxCT,OAwCS,CAxCD,CAwCC,EAxCE,CAwCF,CAAA,GAxCO,CAwCP,GAAA,KAAA,CAAA,EAAA,IAAA,IAvCjB,CAuCiB;iBAtCZ,4BAA4B,IAAI,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnD,4BAA4B,UACnC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,yBACP,eACK,IAAI,SAAS"}

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

@@ -1,67 +0,0 @@
-//#region src/is-strict-equal.d.ts
-/**
- * Determines whether two values are *functionally identical* in all contexts.
- * For primitive values (string, number), this is done by-value, and for objects
- * it is done by-reference (i.e., they point to the same object in memory).
- *
- * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
- * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
- * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
- * `Object.is(-0, 0) === false`).
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
- * objects "by-value", and recurses for every item.
- * - `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.isStrictEqual(data, other)
- * @example
- *    P.isStrictEqual(1, 1) //=> true
- *    P.isStrictEqual(1, '1') //=> false
- *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isStrictEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;
-/**
- * Determines whether two values are *functionally identical* in all contexts.
- * For primitive values (string, number), this is done by-value, and for objects
- * it is done by-reference (i.e., they point to the same object in memory).
- *
- * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
- * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
- * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
- * `Object.is(-0, 0) === false`).
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
- * objects "by-value", and recurses for every item.
- * - `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.isStrictEqual(other)(data)
- * @example
- *    P.pipe(1, P.isStrictEqual(1)); //=> true
- *    P.pipe(1, P.isStrictEqual('1')); //=> false
- *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false
- * @dataLast
- * @category Guard
- */
-declare function isStrictEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isStrictEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
-//#endregion
-export { isStrictEqual };
-//# sourceMappingURL=is-strict-equal.d.cts.map

package/dist/is-strict-equal.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-strict-equal.d.cts","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;AAIA;;;;;;AA+BA;;;;;;;;;;AAGA;;;AAEkB,iBAxCF,aAwCE,CAAA,CAAA,EAAA,UAxCyB,CAwCzB,CAAA,CAAA,IAAA,EAvCV,CAuCU,EAAA,KAAA,EAtCT,CAsCS,SAtCC,OAsCD,CAtCS,CAsCT,EAtCY,CAsCZ,CAAA,GAtCiB,CAsCjB,GAAA,KAAA,CAAA,EAAA,IAAA,IArCP,CAqCO;AAAS,iBApCX,aAoCW,CAAA,CAAA,EAAA,UApCgB,CAoChB,GApCoB,CAoCpB,CAAA,CAAA,IAAA,EApC6B,CAoC7B,EAAA,KAAA,EApCuC,CAoCvC,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBALX,2BAA2B,UAClC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,wBACP,eACK,IAAI,SAAS"}

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

@@ -1,67 +0,0 @@
-//#region src/is-strict-equal.d.ts
-/**
- * Determines whether two values are *functionally identical* in all contexts.
- * For primitive values (string, number), this is done by-value, and for objects
- * it is done by-reference (i.e., they point to the same object in memory).
- *
- * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
- * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
- * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
- * `Object.is(-0, 0) === false`).
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
- * objects "by-value", and recurses for every item.
- * - `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.isStrictEqual(data, other)
- * @example
- *    P.isStrictEqual(1, 1) //=> true
- *    P.isStrictEqual(1, '1') //=> false
- *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false
- * @dataFirst
- * @category Guard
- */
-declare function isStrictEqual<T, S extends T>(data: T, other: T extends Exclude<T, S> ? S : never): data is S;
-declare function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;
-/**
- * Determines whether two values are *functionally identical* in all contexts.
- * For primitive values (string, number), this is done by-value, and for objects
- * it is done by-reference (i.e., they point to the same object in memory).
- *
- * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
- * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`
- * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas
- * `Object.is(-0, 0) === false`).
- *
- * The result would be narrowed to the second value so that the function can be
- * used as a type guard.
- *
- * See:
- * - `isDeepEqual` for a semantic comparison that allows comparing arrays and
- * objects "by-value", and recurses for every item.
- * - `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.isStrictEqual(other)(data)
- * @example
- *    P.pipe(1, P.isStrictEqual(1)); //=> true
- *    P.pipe(1, P.isStrictEqual('1')); //=> false
- *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false
- * @dataLast
- * @category Guard
- */
-declare function isStrictEqual<T, S extends T>(other: T extends Exclude<T, S> ? S : never): (data: T) => data is S;
-declare function isStrictEqual<S>(other: S): <T extends S = S>(data: T) => boolean;
-//#endregion
-export { isStrictEqual };
-//# sourceMappingURL=is-strict-equal.d.ts.map

package/dist/is-strict-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-strict-equal.d.ts","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;AAIA;;;;;;AA+BA;;;;;;;;;;AAGA;;;AAEkB,iBAxCF,aAwCE,CAAA,CAAA,EAAA,UAxCyB,CAwCzB,CAAA,CAAA,IAAA,EAvCV,CAuCU,EAAA,KAAA,EAtCT,CAsCS,SAtCC,OAsCD,CAtCS,CAsCT,EAtCY,CAsCZ,CAAA,GAtCiB,CAsCjB,GAAA,KAAA,CAAA,EAAA,IAAA,IArCP,CAqCO;AAAS,iBApCX,aAoCW,CAAA,CAAA,EAAA,UApCgB,CAoChB,GApCoB,CAoCpB,CAAA,CAAA,IAAA,EApC6B,CAoC7B,EAAA,KAAA,EApCuC,CAoCvC,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBALX,2BAA2B,UAClC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,wBACP,eACK,IAAI,SAAS"}

package/dist/is-string.d.cts

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

package/dist/is-string.d.cts.map

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

package/dist/is-string.d.ts

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

package/dist/is-string.d.ts.map

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

package/dist/is-symbol.d.cts

@@ -1,20 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.cjs";
-
-//#region src/is-symbol.d.ts
-
-/**
- * A function that checks if the passed parameter is a symbol and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is a symbol, false otherwise.
- * @signature
- *    P.isSymbol(data)
- * @example
- *    P.isSymbol(Symbol('foo')) //=> true
- *    P.isSymbol(1) //=> false
- * @category Guard
- */
-declare function isSymbol<T>(data: symbol | T): data is NarrowedTo<T, symbol>;
-//#endregion
-export { isSymbol };
-//# sourceMappingURL=is-symbol.d.cts.map

package/dist/is-symbol.d.cts.map

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

package/dist/is-symbol.d.ts

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

package/dist/is-symbol.d.ts.map

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

package/dist/is-truthy.d.cts

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

package/dist/is-truthy.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-truthy.d.cts","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;;;;;;;;iBAAgB,kBACR,YACG,QAAQ"}

package/dist/is-truthy.d.ts

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

package/dist/is-truthy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-truthy.d.ts","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;;;;;;;;iBAAgB,kBACR,YACG,QAAQ"}