@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/is-error-bQ2IwWHj.cjs

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

package/dist/is-function-DaoOpTFE.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-DpNu_iYN.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-DpNu_iYN.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-function-DpNu_iYN.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-function-o1ixw9eS.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-o1ixw9eS.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-function-o1ixw9eS.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-r9PVEQ1p.js

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-function-r9PVEQ1p.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-included-in-B1CoqHXo.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-BeJz7gyj.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-BeJz7gyj.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in-BeJz7gyj.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-included-in-CPnrdiNI.d.ts

@@ -1,110 +0,0 @@
-import { IsUnion } from "./is-union-CBVcM_uW.js";
-import { IterableContainer } from "./iterable-container-wtkYslN_.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-CPnrdiNI.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in-CPnrdiNI.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-ciZ0ThQh.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-ciZ0ThQh.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in-ciZ0ThQh.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-non-null-BaxoBfPo.js

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-non-null-BaxoBfPo.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-DnDE6zDD.cjs

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

package/dist/is-non-null-DtN0OIEX.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-DtN0OIEX.d.cts.map

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

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

package/dist/is-non-null-Y3FhczVS.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-Y3FhczVS.d.ts.map

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

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

package/dist/is-non-nullish-BW-uIWkn.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-BW-uIWkn.d.cts.map

package/dist/is-non-nullish-BW-uIWkn.d.cts.map

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

package/dist/is-non-nullish-C7zZvb8c.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-C7zZvb8c.d.ts.map

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

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

package/dist/is-non-nullish-CgmLeA39.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-CsmQhBq1.js

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-non-nullish-CsmQhBq1.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-not-C2o5RmWD.cjs

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

package/dist/is-not-CBCnEdKF.js

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

package/dist/is-not-CBCnEdKF.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-not-CBCnEdKF.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"}

package/dist/is-not-DYVAMLBs.d.cts

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

package/dist/is-not-DYVAMLBs.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-not-DYVAMLBs.d.cts","names":[],"sources":["../src/is-not.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;;AAGA;;AAA2C,iBAH3B,KAG2B,CAAA,CAAA,EAAA,UAHR,CAGQ,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAFvB,CAEuB,EAAA,GAAA,IAAA,IAFT,CAES,CAAA,EAAA,CAAA,IAAA,EADjC,CACiC,EAAA,GAAA,IAAA,IADnB,OACmB,CADX,CACW,EADR,CACQ,CAAA;AAAuB,iBAAlD,KAAkD,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAAvB,CAAuB,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAAA,CAAA,EAAA,GAAA,OAAA"}

package/dist/is-not-VNjzMFnp.d.ts

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

package/dist/is-not-VNjzMFnp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-not-VNjzMFnp.d.ts","names":[],"sources":["../src/is-not.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;;AAGA;;AAA2C,iBAH3B,KAG2B,CAAA,CAAA,EAAA,UAHR,CAGQ,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAFvB,CAEuB,EAAA,GAAA,IAAA,IAFT,CAES,CAAA,EAAA,CAAA,IAAA,EADjC,CACiC,EAAA,GAAA,IAAA,IADnB,OACmB,CADX,CACW,EADR,CACQ,CAAA;AAAuB,iBAAlD,KAAkD,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAAvB,CAAuB,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAAA,CAAA,EAAA,GAAA,OAAA"}

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

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

package/dist/is-nullish-CEDQo8Hn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-nullish-CEDQo8Hn.d.ts","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;;;;;;iBAAgB,0BACD,wBACJ,WAAW"}

package/dist/is-nullish-DSaUMZZs.js

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

package/dist/is-nullish-DSaUMZZs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-nullish-DSaUMZZs.js","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is either `null` or\n * `undefined` and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is either `null` or `undefined`, false\n * otherwise.\n * @signature\n *    P.isNullish(data)\n * @example\n *    P.isNullish(undefined) //=> true\n *    P.isNullish(null) //=> true\n *    P.isNullish('somethingElse') //=> false\n * @category Guard\n */\nexport function isNullish<T>(\n  data: null | T | undefined,\n): data is NarrowedTo<T, null | undefined> {\n  return data === null || data === undefined;\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACyC,CACzC,OAAO,GAAS"}

package/dist/is-nullish-Dd6vFJuS.cjs

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

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

@@ -1,23 +0,0 @@
-import { NarrowedTo } from "./narrowed-to-BTrqm7Xt.cjs";
-
-//#region src/is-nullish.d.ts
-
-/**
- * A function that checks if the passed parameter is either `null` or
- * `undefined` and narrows its type accordingly.
- *
- * @param data - The variable to check.
- * @returns True if the passed input is either `null` or `undefined`, false
- * otherwise.
- * @signature
- *    P.isNullish(data)
- * @example
- *    P.isNullish(undefined) //=> true
- *    P.isNullish(null) //=> true
- *    P.isNullish('somethingElse') //=> false
- * @category Guard
- */
-declare function isNullish<T>(data: null | T | undefined): data is NarrowedTo<T, null | undefined>;
-//#endregion
-export { isNullish };
-//# sourceMappingURL=is-nullish-Djw8KpQn.d.cts.map

package/dist/is-nullish-Djw8KpQn.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-nullish-Djw8KpQn.d.cts","names":[],"sources":["../src/is-nullish.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;;;;;;iBAAgB,0BACD,wBACJ,WAAW"}

package/dist/is-number-CTdFYf2z.d.cts

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

package/dist/is-number-CTdFYf2z.d.cts.map

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

package/dist/is-number-CZ5Eb2Cm.d.ts

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

package/dist/is-number-CZ5Eb2Cm.d.ts.map

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

package/dist/is-number-DRJ5I-tT.js

@@ -1,2 +0,0 @@
-function e(e){return typeof e==`number`&&!Number.isNaN(e)}export{e as isNumber};
-//# sourceMappingURL=is-number-DRJ5I-tT.js.map