@vinicunca/perkakas 1.9.0 → 1.13.0

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

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

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

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

package/dist/is-emptyish-EQIjUNpM.js

@@ -1,2 +0,0 @@
-function e(e){if(e==null||e===``)return!0;if(typeof e!=`object`)return!1;if(`length`in e&&typeof e.length==`number`)return e.length===0;if(`size`in e&&typeof e.size==`number`)return e.size===0;for(let t in e)return!1;return Object.getOwnPropertySymbols(e).length===0}export{e as isEmptyish};
-//# sourceMappingURL=is-emptyish-EQIjUNpM.js.map

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

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

package/dist/is-error-3lCqN0ZV.cjs

@@ -1 +0,0 @@
-function e(e){return e instanceof Error}Object.defineProperty(exports,`isError`,{enumerable:!0,get:function(){return e}});

package/dist/is-error-78KeswTB.js

@@ -1,2 +0,0 @@
-function e(e){return e instanceof Error}export{e as isError};
-//# sourceMappingURL=is-error-78KeswTB.js.map

package/dist/is-error-78KeswTB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-error-78KeswTB.js","names":[],"sources":["../src/is-error.ts"],"sourcesContent":["type DefinitelyError<T>\n  = Extract<T, Error> extends never ? Error : Extract<T, Error>;\n/**\n * A function that checks if the passed parameter is an Error and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is an Error, false otherwise.\n * @signature\n *    P.isError(data)\n * @example\n *    P.isError(new Error('message')) //=> true\n *    P.isError('somethingElse') //=> false\n * @category Guard\n */\nexport function isError<T>(data: Error | T): data is DefinitelyError<T> {\n  return data instanceof Error;\n}\n"],"mappings":"AAcA,SAAgB,EAAW,EAA6C,CACtE,OAAO,aAAgB"}

package/dist/is-error-BaSTm9Oy.d.ts

@@ -1,18 +0,0 @@
-//#region src/is-error.d.ts
-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>;
-//#endregion
-export { isError };
-//# sourceMappingURL=is-error-BaSTm9Oy.d.ts.map

package/dist/is-error-BaSTm9Oy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-error-BaSTm9Oy.d.ts","names":[],"sources":["../src/is-error.ts"],"sourcesContent":[],"mappings":";KAAK,qBACD,QAAQ,GAAG,uBAAuB,QAAQ,QAAQ,GAAG;;;;;;;;;;;AAazD;;AAAiC,iBAAjB,OAAiB,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,KAAA,GAAQ,CAAR,CAAA,EAAA,IAAA,IAAoB,eAApB,CAAoC,CAApC,CAAA"}

package/dist/is-error-CRs0usTg.d.cts

@@ -1,18 +0,0 @@
-//#region src/is-error.d.ts
-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>;
-//#endregion
-export { isError };
-//# sourceMappingURL=is-error-CRs0usTg.d.cts.map

package/dist/is-error-CRs0usTg.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-error-CRs0usTg.d.cts","names":[],"sources":["../src/is-error.ts"],"sourcesContent":[],"mappings":";KAAK,qBACD,QAAQ,GAAG,uBAAuB,QAAQ,QAAQ,GAAG;;;;;;;;;;;AAazD;;AAAiC,iBAAjB,OAAiB,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,KAAA,GAAQ,CAAR,CAAA,EAAA,IAAA,IAAoB,eAApB,CAAoC,CAApC,CAAA"}

package/dist/is-function-BwWA5uZn.js

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

package/dist/is-function-BwWA5uZn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-function-BwWA5uZn.js","names":[],"sources":["../src/is-function.ts"],"sourcesContent":["/* eslint-disable ts/no-unsafe-function-type --\n * Function is used generically in this file to define any type of function, so\n * this lint error is not relevant for it.\n */\ntype DefinitelyFunction<T>\n  = Extract<T, Function> extends never ? Function : Extract<T, Function>;\n/**\n * A function that checks if the passed parameter is a Function and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Function, false otherwise.\n * @signature\n *    P.isFunction(data)\n * @example\n *    P.isFunction(() => {}) //=> true\n *    P.isFunction('somethingElse') //=> false\n * @category Guard\n */\nexport function isFunction<T>(\n  data: Function | T,\n): data is DefinitelyFunction<T> {\n  return typeof data === 'function';\n}\n"],"mappings":"AAkBA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS"}

package/dist/is-function-CUUJoPVT.d.cts

@@ -1,18 +0,0 @@
-//#region src/is-function.d.ts
-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>;
-//#endregion
-export { isFunction };
-//# sourceMappingURL=is-function-CUUJoPVT.d.cts.map

package/dist/is-function-CUUJoPVT.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-function-CUUJoPVT.d.cts","names":[],"sources":["../src/is-function.ts"],"sourcesContent":[],"mappings":";KAIK,wBACD,QAAQ,GAAG,0BAA0B,WAAW,QAAQ,GAAG;;;;;;;;;;;AAa/D;;AACQ,iBADQ,UACR,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,QAAA,GAAW,CAAX,CAAA,EAAA,IAAA,IACG,kBADH,CACsB,CADtB,CAAA"}

package/dist/is-function-DCafs0vu.cjs

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

package/dist/is-function-RTVlC34T.d.ts

@@ -1,18 +0,0 @@
-//#region src/is-function.d.ts
-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>;
-//#endregion
-export { isFunction };
-//# sourceMappingURL=is-function-RTVlC34T.d.ts.map

package/dist/is-function-RTVlC34T.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-function-RTVlC34T.d.ts","names":[],"sources":["../src/is-function.ts"],"sourcesContent":[],"mappings":";KAIK,wBACD,QAAQ,GAAG,0BAA0B,WAAW,QAAQ,GAAG;;;;;;;;;;;AAa/D;;AACQ,iBADQ,UACR,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,QAAA,GAAW,CAAX,CAAA,EAAA,IAAA,IACG,kBADH,CACsB,CADtB,CAAA"}

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

@@ -1,110 +0,0 @@
-import { IsUnion } from "./is-union-J33UR5By.js";
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { IsLiteral } from "type-fest";
-
-//#region src/is-included-in.d.ts
-
-/**
- * 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;
-//#endregion
-export { isIncludedIn };
-//# sourceMappingURL=is-included-in-BPf-vizg.d.ts.map

package/dist/is-included-in-BPf-vizg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in-BPf-vizg.d.ts","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAE6E;;;;;;;;;;AAoBtD;KALlB,eAsCY,CAAA,UAtCc,iBAsCd,CAAA,GAtCmC,CAsCnC,SAAA,SAAA,EAAA,GAAA,IAAA,GApCb,CAoCa,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAnCX,OAmCW,CAnCH,IAmCG,CAAA,SAAA,IAAA,GAAA,KAAA,GAjCT,eAiCS,CAjCO,IAiCP,CAAA,GAAA,KAAA;;;;;;;;;;AAwCjB;;;;;;;;;;;AAIA;;;;;;;AAgCA;;;KA5EK,YA4EqC,CAAA,CAAA,EAAA,UA5EX,iBA4EW,CA5EO,CA4EP,CAAA,CAAA,GA3EtC,SA2EsC,CA3E5B,CA2E4B,CAAA,SAAA,IAAA,GAnEpC,eAmEoC,CAnEpB,CAmEoB,CAAA,GA/DpC,SA+DoC,CA/D1B,CA+D0B,CAAA,MAAA,CAAA,CAAA;;;;;;;;AAG1C;;;;;;;;;;;;;;;;;;iBAvCgB,0BAA0B,kBAAkB,UACpD,cACK,aAAa,GAAG,kBAAkB,oBACpC;iBACK,0BAA0B,SAClC,cACK,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bf,0BAA0B,kBAAkB,eAC/C,aAAa,GAAG,kBAAkB,mBACrC,cAAc;iBACR,0BAA0B,cAC7B,kBAAkB,YACrB"}

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

@@ -1,110 +0,0 @@
-import { IsUnion } from "./is-union-BEGCMhOi.cjs";
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { IsLiteral } from "type-fest";
-
-//#region src/is-included-in.d.ts
-
-/**
- * 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;
-//#endregion
-export { isIncludedIn };
-//# sourceMappingURL=is-included-in-Bgc9XbPZ.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in-Bgc9XbPZ.d.cts","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAE6E;;;;;;;;;;AAoBtD;KALlB,eAsCY,CAAA,UAtCc,iBAsCd,CAAA,GAtCmC,CAsCnC,SAAA,SAAA,EAAA,GAAA,IAAA,GApCb,CAoCa,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAnCX,OAmCW,CAnCH,IAmCG,CAAA,SAAA,IAAA,GAAA,KAAA,GAjCT,eAiCS,CAjCO,IAiCP,CAAA,GAAA,KAAA;;;;;;;;;;AAwCjB;;;;;;;;;;;AAIA;;;;;;;AAgCA;;;KA5EK,YA4EqC,CAAA,CAAA,EAAA,UA5EX,iBA4EW,CA5EO,CA4EP,CAAA,CAAA,GA3EtC,SA2EsC,CA3E5B,CA2E4B,CAAA,SAAA,IAAA,GAnEpC,eAmEoC,CAnEpB,CAmEoB,CAAA,GA/DpC,SA+DoC,CA/D1B,CA+D0B,CAAA,MAAA,CAAA,CAAA;;;;;;;;AAG1C;;;;;;;;;;;;;;;;;;iBAvCgB,0BAA0B,kBAAkB,UACpD,cACK,aAAa,GAAG,kBAAkB,oBACpC;iBACK,0BAA0B,SAClC,cACK,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bf,0BAA0B,kBAAkB,eAC/C,aAAa,GAAG,kBAAkB,mBACrC,cAAc;iBACR,0BAA0B,cAC7B,kBAAkB,YACrB"}

package/dist/is-included-in-Cyf_CvyT.cjs

@@ -1 +0,0 @@
-function e(e,t){if(t===void 0){let t=new Set(e);return e=>t.has(e)}return t.includes(e)}Object.defineProperty(exports,`isIncludedIn`,{enumerable:!0,get:function(){return e}});

package/dist/is-included-in-sNQGRURb.js

@@ -1,2 +0,0 @@
-function e(e,t){if(t===void 0){let t=new Set(e);return e=>t.has(e)}return t.includes(e)}export{e as isIncludedIn};
-//# sourceMappingURL=is-included-in-sNQGRURb.js.map

package/dist/is-included-in-sNQGRURb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in-sNQGRURb.js","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":["import type { IsLiteral } from 'type-fest';\nimport type { IsUnion } from './internal/types/is-union';\nimport type { IterableContainer } from './internal/types/iterable-container';\n\n/**\n * A \"constant\" tuple is a type that has a single runtime value that can fulfil\n * it. This means that it doesn't have any variadic/rest/spread/array parts, and\n * that all it's values are singular (non-union) literals.\n *\n * We use this type to allow narrowing when checking against a set of values\n * defined as a const.\n *\n * @example\n *   type T1 = IsConstantTuple<[\"cat\", \"dog\", 3, true]>; // => true;\n *   type T2 = IsConstantTuple<[\"cat\" | \"dog\"]>; // false;\n *   type T2 = IsConstantTuple<[\"cat\", ...Array<\"cat\">]>; // false;\n */\ntype IsConstantTuple<T extends IterableContainer> = T extends readonly []\n  ? true\n  : T extends readonly [infer Head, ...infer Rest]\n    ? IsUnion<Head> extends true\n      ? false\n      : IsConstantTuple<Rest>\n    : false;\n\n/**\n * There is no way to tell Typescript to only narrow the \"accepted\" side of a\n * type-predicate and so in many cases the negated side is also affected, this\n * results in over-narrowing in many cases, breaking typing. For this reason we\n * only want to use the type-predicate variant of `isIncludedIn` when we can\n * assume the result represents the expected types (closely enough). This is not\n * and ideal solution and we will still generate wrong types in some cases (see\n * tests), but it reduces the surface of this problem significantly, while still\n * keeping the utility of `isIncludedIn` for the common cases.\n *\n * TL;DR - The types are narrowable when: T is literal and S is a pure tuple, or\n * when T isn't a literal, but S is.\n *\n * @example\n *   const data = 1 as 1 | 2 | 3;\n *   const container = [] as Array<1 | 2>;\n *   if (isIncludedIn(data, container)) {\n *     ... it makes sense to narrow data to `1 | 2` as the value `3` is not part\n *     ... of the typing of container, so will never result in being true.\n *   } else {\n *     ... but it doesn't make sense to narrow the value to 3 here, because 1\n *     ... and 2 are still valid values for data, when container doesn't include\n *     ... them **at runtime**.\n *     ... Typescript narrows the _rejected_ branch based on how it narrowed the\n *     ... _accepted_ clause, and we can't control that; because our input type\n *     ... is `1 | 2 | 3` and the accepted side is `1 | 2`, the rejected side is\n *     ... typed `Exclude<1 | 2 | 3, 1 | 2>`, which is `3`.\n *   }\n * }\n */\ntype IsNarrowable<T, S extends IterableContainer<T>>\n  = IsLiteral<T> extends true\n    // When T is literal (i.g. it isn't a primitive type like `string` or\n    // `number`) then the criteria for narrowing is that the container is a\n    // \"pure\" tuple because we *assume* that S represents a constant set of\n    // values, and that it's typing also represents it's runtime content 1-\n    // for-1. If S isn't a pure tuple it means we can't tell from the typing\n    // which of it's values are actually present in runtime so can't use them\n    // to narrow correctly.\n    ? IsConstantTuple<S>\n    // When T isn't a literal type but the items in S are we can narrow the\n    // type because it won't affect the negated side (`Exclude<number, 3>`\n    // is still `number`).\n    : IsLiteral<S[number]>;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param data - The item that is checked.\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   P.isIncludedIn(data, container);\n * @example\n *   P.isIncludedIn(2, [1, 2, 3]); // => true\n *   P.isIncludedIn(4, [1, 2, 3]); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   P.isIncludedIn(data, [\"cat\", \"dog\"] as const); // true (typed \"cat\" | \"dog\");\n * @dataFirst\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  data: T,\n  container: IsNarrowable<T, S> extends true ? S : never,\n): data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  data: T,\n  container: IterableContainer<S>,\n): boolean;\n\n/**\n * Checks if the item is included in the container. This is a wrapper around\n * `Array.prototype.includes` and `Set.prototype.has` and thus relies on the\n * same equality checks that those functions do (which is reference equality,\n * e.g. `===`). In some cases the input's type is also narrowed to the\n * container's item types.\n *\n * Notice that unlike most functions, this function takes a generic item as it's\n * data and **an array** as it's parameter.\n *\n * @param container - The items that are checked against.\n * @returns `true` if the item is in the container, or `false` otherwise. In\n * cases the type of `data` is also narrowed down.\n * @signature\n *   P.isIncludedIn(container)(data);\n * @example\n *   P.pipe(2, P.isIncludedIn([1, 2, 3])); // => true\n *   P.pipe(4, P.isIncludedIn([1, 2, 3])); // => false\n *\n *   const data = \"cat\" as \"cat\" | \"dog\" | \"mouse\";\n *   P.pipe(\n *     data,\n *     P.isIncludedIn([\"cat\", \"dog\"] as const),\n *   ); // => true (typed \"cat\" | \"dog\");\n * @dataLast\n * @category Guard\n */\nexport function isIncludedIn<T, S extends IterableContainer<T>>(\n  container: IsNarrowable<T, S> extends true ? S : never,\n): (data: T) => data is S[number];\nexport function isIncludedIn<T, S extends T>(\n  container: IterableContainer<S>,\n): (data: T) => boolean;\n\nexport function isIncludedIn(\n  dataOrContainer: unknown,\n  container?: ReadonlyArray<unknown>,\n): unknown {\n  if (container === undefined) {\n    // === dataLast ===\n    // We don't use curry here because we can optimize the dataLast case by\n    // memoizing a set and accessing it in O(1) time instead of scanning the\n    // array **each time** (O(n)) each time.\n    const asSet = new Set(dataOrContainer as ReadonlyArray<unknown>);\n    return (data: unknown) => asSet.has(data);\n  }\n\n  // === dataFirst ===\n  return container.includes(dataOrContainer);\n}\n"],"mappings":"AA0IA,SAAgB,EACd,EACA,EACS,CACT,GAAI,IAAc,IAAA,GAAW,CAK3B,IAAM,EAAQ,IAAI,IAAI,EAA0C,CAChE,MAAQ,IAAkB,EAAM,IAAI,EAAK,CAI3C,OAAO,EAAU,SAAS,EAAgB"}

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

@@ -1,19 +0,0 @@
-//#region src/is-non-null.d.ts
-/**
- * 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;
-//#endregion
-export { isNonNull };
-//# sourceMappingURL=is-non-null-BN4w5Uvv.d.cts.map

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

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

package/dist/is-non-null-ByX4cCc9.js

@@ -1,2 +0,0 @@
-function e(e){return e!==null}export{e as isNonNull};
-//# sourceMappingURL=is-non-null-ByX4cCc9.js.map

package/dist/is-non-null-ByX4cCc9.js.map

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

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

@@ -1,19 +0,0 @@
-//#region src/is-non-null.d.ts
-/**
- * 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;
-//#endregion
-export { isNonNull };
-//# sourceMappingURL=is-non-null-CkhUFCj7.d.ts.map

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

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

package/dist/is-non-null-ottNSI71.cjs

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

package/dist/is-non-nullish-CPYxcbdK.js

@@ -1,2 +0,0 @@
-function e(e){return e!=null}export{e as isNonNullish};
-//# sourceMappingURL=is-non-nullish-CPYxcbdK.js.map

package/dist/is-non-nullish-CPYxcbdK.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-non-nullish-CPYxcbdK.js","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is defined *AND* isn't `null`\n * and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is defined and isn't `null`, false\n * otherwise.\n * @signature\n *    P.isNonNullish(data)\n * @example\n *    P.isNonNullish('string') //=> true\n *    P.isNonNullish(null) //=> false\n *    P.isNonNullish(undefined) //=> false\n * @category Guard\n */\nexport function isNonNullish<T>(data: T): data is NonNullable<T> {\n  return data !== undefined && data !== null;\n}\n"],"mappings":"AAeA,SAAgB,EAAgB,EAAiC,CAC/D,OAAO,GAA+B"}

package/dist/is-non-nullish-Ck7WAiku.cjs

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

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

@@ -1,20 +0,0 @@
-//#region src/is-non-nullish.d.ts
-/**
- * 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>;
-//#endregion
-export { isNonNullish };
-//# sourceMappingURL=is-non-nullish-D6EU-vIp.d.cts.map

package/dist/is-non-nullish-D6EU-vIp.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-non-nullish-D6EU-vIp.d.cts","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;;;;;;;iBAAgB,sBAAsB,YAAY,YAAY"}

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

@@ -1,20 +0,0 @@
-//#region src/is-non-nullish.d.ts
-/**
- * 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>;
-//#endregion
-export { isNonNullish };
-//# sourceMappingURL=is-non-nullish-O32x0PJp.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-non-nullish-O32x0PJp.d.ts","names":[],"sources":["../src/is-non-nullish.ts"],"sourcesContent":[],"mappings":";;AAeA;;;;;;;;;;;;;;iBAAgB,sBAAsB,YAAY,YAAY"}

package/dist/is-not-5po8Jiji.js

@@ -1,2 +0,0 @@
-function e(e){return t=>!e(t)}export{e as isNot};
-//# sourceMappingURL=is-not-5po8Jiji.js.map

package/dist/is-not-5po8Jiji.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-not-5po8Jiji.js","names":[],"sources":["../src/is-not.ts"],"sourcesContent":["/**\n * A function that takes a guard function as predicate and returns a guard that negates it.\n *\n * @param predicate - The guard function to negate.\n * @returns Function A guard function.\n * @signature\n *    P.isNot(P.isTruthy)(data)\n * @example\n *    P.isNot(P.isTruthy)(false) //=> true\n *    P.isNot(P.isTruthy)(true) //=> false\n * @dataLast\n * @category Guard\n */\nexport function isNot<T, S extends T>(\n  predicate: (data: T) => data is S,\n): (data: T) => data is Exclude<T, S>;\nexport function isNot<T>(predicate: (data: T) => boolean): (data: T) => boolean;\n\nexport function isNot<T>(predicate: (data: T) => boolean) {\n  return (data: T): boolean => !predicate(data);\n}\n"],"mappings":"AAkBA,SAAgB,EAAS,EAAiC,CACxD,MAAQ,IAAqB,CAAC,EAAU,EAAK"}