@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/is-plain-object-BlyD-E-m.d.ts

@@ -1,33 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-C6wP224-.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-BlyD-E-m.d.ts.map

package/dist/is-plain-object-BlyD-E-m.d.ts.map

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

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

@@ -1,33 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-BTrqm7Xt.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-BvL_W8IP.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object-BvL_W8IP.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-Cnx_x0Ei.js

@@ -1,2 +0,0 @@
-function e(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}export{e as isPlainObject};
-//# sourceMappingURL=is-plain-object-Cnx_x0Ei.js.map

package/dist/is-plain-object-Cnx_x0Ei.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object-Cnx_x0Ei.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * 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.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    P.isPlainObject(data)\n * @example\n *    // true\n *    P.isPlainObject({}) //=> true\n *    P.isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    P.isPlainObject([]) //=> false\n *    P.isPlainObject(Promise.resolve(\"something\")) //=> false\n *    P.isPlainObject(new Date()) //=> false\n *    P.isPlainObject(new Error(\"error\")) //=> false\n *    P.isPlainObject('somethingElse') //=> false\n *    P.isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data === null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}

package/dist/is-promise-CcLSSGQE.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-CcLSSGQE.d.ts.map

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

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

package/dist/is-promise-DbVIpcYL.js

@@ -1,2 +0,0 @@
-function e(e){return e instanceof Promise}export{e as isPromise};
-//# sourceMappingURL=is-promise-DbVIpcYL.js.map

package/dist/is-promise-DbVIpcYL.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-promise-DbVIpcYL.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    P.isPromise(data)\n * @example\n *    P.isPromise(Promise.resolve(5)) //=> true\n *    P.isPromise(Promise.reject(5)) //=> true\n *    P.isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T, S>(data: Promise<T> | S): data is Promise<T> {\n  return data instanceof Promise;\n}\n"],"mappings":"AAaA,SAAgB,EAAgB,EAA0C,CACxE,OAAO,aAAgB"}

package/dist/is-promise-VSzOkl6R.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-VSzOkl6R.d.cts.map

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

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

package/dist/is-shallow-equal-BygWppM-.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.prototype.hasOwnProperty.call(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}export{t as isShallowEqual};
-//# sourceMappingURL=is-shallow-equal-BygWppM-.js.map

package/dist/is-shallow-equal-BygWppM-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-shallow-equal-BygWppM-.js","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isShallowEqual(data, other)\n * @example\n *    P.isShallowEqual(1, 1) //=> true\n *    P.isShallowEqual(1, '1') //=> false\n *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isShallowEqual(other)(data)\n * @example\n *    P.pipe(1, P.isShallowEqual(1)) //=> true\n *    P.pipe(1, P.isShallowEqual('1')) //=> false\n *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true\n *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<S>(\n  other: S,\n): <T extends S = S>(data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"4CA8EA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,UAAU,eAAe,KAAK,EAAG,EAAI,CAC/C,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}

package/dist/is-shallow-equal-DQCnwLNk.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-DQCnwLNk.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-shallow-equal-DQCnwLNk.d.ts","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;;AAIA;;;;;;;AAiCA;;;;;;;;;;;AAGA;;AACS,iBAzCO,cAyCP,CAAA,CAAA,EAAA,UAzCmC,CAyCnC,CAAA,CAAA,IAAA,EAxCD,CAwCC,EAAA,KAAA,EAvCA,CAuCA,SAvCU,OAuCV,CAvCkB,CAuClB,EAvCqB,CAuCrB,CAAA,GAvC0B,CAuC1B,GAAA,KAAA,CAAA,EAAA,IAAA,IAtCE,CAsCF;AACK,iBAtCE,cAsCF,CAAA,CAAA,EAAA,UAtC8B,CAsC9B,GAtCkC,CAsClC,CAAA,CAAA,IAAA,EAtC2C,CAsC3C,EAAA,KAAA,EAtCqD,CAsCrD,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBALE,4BAA4B,UACnC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,yBACP,eACK,IAAI,SAAS"}

package/dist/is-shallow-equal-DuVbTG3f.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-DuVbTG3f.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-shallow-equal-DuVbTG3f.d.cts","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":[],"mappings":";;AAkCA;;;;;;;;;;;AAIA;;;;;;;AAiCA;;;;;;;;;;;AAGA;;AACS,iBAzCO,cAyCP,CAAA,CAAA,EAAA,UAzCmC,CAyCnC,CAAA,CAAA,IAAA,EAxCD,CAwCC,EAAA,KAAA,EAvCA,CAuCA,SAvCU,OAuCV,CAvCkB,CAuClB,EAvCqB,CAuCrB,CAAA,GAvC0B,CAuC1B,GAAA,KAAA,CAAA,EAAA,IAAA,IAtCE,CAsCF;AACK,iBAtCE,cAsCF,CAAA,CAAA,EAAA,UAtC8B,CAsC9B,GAtCkC,CAsClC,CAAA,CAAA,IAAA,EAtC2C,CAsC3C,EAAA,KAAA,EAtCqD,CAsCrD,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBALE,4BAA4B,UACnC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,yBACP,eACK,IAAI,SAAS"}

package/dist/is-strict-equal-2zT4bfOn.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){return e===t||Object.is(e,t)}export{t as isStrictEqual};
-//# sourceMappingURL=is-strict-equal-2zT4bfOn.js.map

package/dist/is-strict-equal-2zT4bfOn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-strict-equal-2zT4bfOn.js","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isStrictEqual(data, other)\n * @example\n *    P.isStrictEqual(1, 1) //=> true\n *    P.isStrictEqual(1, '1') //=> false\n *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isStrictEqual(other)(data)\n * @example\n *    P.pipe(1, P.isStrictEqual(1)); //=> true\n *    P.pipe(1, P.isStrictEqual('1')); //=> false\n *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<S>(\n  other: S,\n): <T extends S = S>(data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T, S>(data: S | T, other: S): data is S {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"4CA0EA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EAAoC,EAAa,EAAqB,CAC7E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}

package/dist/is-strict-equal-5yvkDn8Q.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-5yvkDn8Q.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-strict-equal-5yvkDn8Q.d.ts","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;;AAIA;;;;;;;AA+BA;;;;;;;;;;;AAGgB,iBAtCA,aAsCa,CAAA,CAAA,EAAA,UAtCc,CAsCd,CAAA,CAAA,IAAA,EArCrB,CAqCqB,EAAA,KAAA,EApCpB,CAoCoB,SApCV,OAoCU,CApCF,CAoCE,EApCC,CAoCD,CAAA,GApCM,CAoCN,GAAA,KAAA,CAAA,EAAA,IAAA,IAnClB,CAmCkB;AAAA,iBAlCb,aAkCa,CAAA,CAAA,EAAA,UAlCc,CAkCd,GAlCkB,CAkClB,CAAA,CAAA,IAAA,EAlC2B,CAkC3B,EAAA,KAAA,EAlCqC,CAkCrC,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHb,2BAA2B,UAClC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,wBACP,eACK,IAAI,SAAS"}

package/dist/is-strict-equal-Ct5kAZ5_.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-Ct5kAZ5_.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-strict-equal-Ct5kAZ5_.d.cts","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":[],"mappings":";;AAgCA;;;;;;;;;;;AAIA;;;;;;;AA+BA;;;;;;;;;;;AAGgB,iBAtCA,aAsCa,CAAA,CAAA,EAAA,UAtCc,CAsCd,CAAA,CAAA,IAAA,EArCrB,CAqCqB,EAAA,KAAA,EApCpB,CAoCoB,SApCV,OAoCU,CApCF,CAoCE,EApCC,CAoCD,CAAA,GApCM,CAoCN,GAAA,KAAA,CAAA,EAAA,IAAA,IAnClB,CAmCkB;AAAA,iBAlCb,aAkCa,CAAA,CAAA,EAAA,UAlCc,CAkCd,GAlCkB,CAkClB,CAAA,CAAA,IAAA,EAlC2B,CAkC3B,EAAA,KAAA,EAlCqC,CAkCrC,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHb,2BAA2B,UAClC,UAAU,QAAQ,GAAG,KAAK,mBACzB,cAAc;iBACR,wBACP,eACK,IAAI,SAAS"}

package/dist/is-string-A-koYYS3.js

@@ -1,2 +0,0 @@
-function e(e){return typeof e==`string`}export{e as isString};
-//# sourceMappingURL=is-string-A-koYYS3.js.map

package/dist/is-string-A-koYYS3.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-string-A-koYYS3.js","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a string and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a string, false otherwise.\n * @signature\n *    P.isString(data)\n * @example\n *    P.isString('string') //=> true\n *    P.isString(1) //=> false\n * @category Guard\n */\nexport function isString<T>(data: string | T): data is NarrowedTo<T, string> {\n  return typeof data === 'string';\n}\n"],"mappings":"AAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}

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

@@ -1,20 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-C6wP224-.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-DAe_2BJR.d.ts.map

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

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

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

@@ -1,20 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-BTrqm7Xt.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-wfqO0Lag.d.cts.map

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

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

package/dist/is-symbol-CIR-W22K.d.cts

@@ -1,20 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-BTrqm7Xt.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-CIR-W22K.d.cts.map

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

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

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

@@ -1,20 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-C6wP224-.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-CVwn3meF.d.ts.map

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

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

package/dist/is-symbol-Vzo5mVUM.js

@@ -1,2 +0,0 @@
-function e(e){return typeof e==`symbol`}export{e as isSymbol};
-//# sourceMappingURL=is-symbol-Vzo5mVUM.js.map

package/dist/is-symbol-Vzo5mVUM.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-symbol-Vzo5mVUM.js","names":[],"sources":["../src/is-symbol.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a symbol and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a symbol, false otherwise.\n * @signature\n *    P.isSymbol(data)\n * @example\n *    P.isSymbol(Symbol('foo')) //=> true\n *    P.isSymbol(1) //=> false\n * @category Guard\n */\nexport function isSymbol<T>(data: symbol | T): data is NarrowedTo<T, symbol> {\n  return typeof data === 'symbol';\n}\n"],"mappings":"AAcA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}

package/dist/is-truthy-CoTXzAuK.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-CoTXzAuK.d.cts.map

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

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