@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/is-emptyish.test.js

@@ -1,2 +0,0 @@
-import{a as e,i as t,n}from"./dist-Bd1vawFi.js";import{isEmptyish as r}from"./is-emptyish.js";t(`nullish`,()=>{e(`null`,()=>{n(r(null)).toBe(!0)}),e(`undefined`,()=>{n(r(void 0)).toBe(!0)})}),t(`strings`,()=>{e(`literals`,()=>{n(r(``)).toBe(!0),n(r(`test`)).toBe(!1)}),e(`boxed`,()=>{n(r(new String(``))).toBe(!0),n(r(new String(`test`))).toBe(!1)})}),t(`arrays`,()=>{e(`simple`,()=>{n(r([])).toBe(!0),n(r([1,2,3])).toBe(!1)}),e(`sparse`,()=>{n(r([,,])).toBe(!1)}),e(`via Array.from`,()=>{n(r(Array.from({length:0}))).toBe(!0),n(r(Array.from({length:10}))).toBe(!1)}),e(`typed arrays`,()=>{n(r(new Int8Array)).toBe(!0),n(r(new Int8Array([1,2,3]))).toBe(!1)}),e(`buffers`,()=>{n(r(Buffer.alloc(0))).toBe(!0),n(r(Buffer.alloc(3))).toBe(!1)}),e(`sets`,()=>{n(r(new Set)).toBe(!0),n(r(new Set([1,2,3]))).toBe(!1)}),e("array-like (e.g., `arguments`)",()=>{function e(){n(r(arguments)).toBe(!0)}e();function t(e,t,i){n(r(arguments)).toBe(!1)}t(`test`,123,!0)})}),t(`keyed collections`,()=>{e(`plain objects`,()=>{n(r({})).toBe(!0),n(r({key:`value`})).toBe(!1)}),e(`null-prototyped objects`,()=>{let e=Object.create(null);n(r(e)).toBe(!0),e.key=`hello, world!`,n(r(e)).toBe(!1)}),e(`symbol props`,()=>{n(r({[Symbol(`hello`)]:`world`})).toBe(!1)}),e(`maps`,()=>{n(r(new Map)).toBe(!0),n(r(new Map([[`key`,`value`]]))).toBe(!1)}),e(`url search params`,()=>{n(r(new URLSearchParams)).toBe(!0),n(r(new URLSearchParams(``))).toBe(!0),n(r(new URLSearchParams(`?`))).toBe(!0),n(r(new URLSearchParams(`hello`))).toBe(!1),n(r(new URLSearchParams({hello:`world `}))).toBe(!1)}),e(`prototype chains`,()=>{n(r(Object.create(Object.create({})))).toBe(!0),n(r(Object.create(Object.create({a:123})))).toBe(!1)})}),t(`self-declared sizes`,()=>{e(`length`,()=>{n(r({length:0})).toBe(!0),n(r({length:1})).toBe(!1)}),e(`size`,()=>{n(r({size:0})).toBe(!0),n(r({size:1})).toBe(!1)}),e(`props are not coerced`,()=>{n(r({length:`0`})).toBe(!1),n(r({size:null})).toBe(!1)}),e(`length has precedence over size`,()=>{n(r({length:0,size:5})).toBe(!0),n(r({length:1,size:0})).toBe(!1)})}),t(`unsupported types`,()=>{t(`always false`,()=>{e(`numbers`,()=>{n(r(0)).toBe(!1),n(r(-0)).toBe(!1),n(r(NaN)).toBe(!1),n(r(1/0)).toBe(!1),n(r(100)).toBe(!1),n(r(12.34)).toBe(!1)}),e(`bigints`,()=>{n(r(0n)).toBe(!1),n(r(1n)).toBe(!1)}),e(`booleans`,()=>{n(r(!1)).toBe(!1),n(r(!0)).toBe(!1)}),e(`symbols`,()=>{n(r(Symbol(``))).toBe(!1),n(r(Symbol(`something`))).toBe(!1)}),e(`functions`,()=>{n(r(()=>{})).toBe(!1),n(r(()=>{console.log(`hello`)})).toBe(!1)})}),e(`classes`,()=>{class e{}class t{a=`hello`}class i{#e=`hello`;get a(){return this.#e}}class a{data=[]}n(r(new e)).toBe(!0),n(r(new t)).toBe(!1),n(r(new i)).toBe(!0),n(r(new a)).toBe(!1)}),e(`errors`,()=>{class e extends Error{constructor(e=`hello`){super(),this.data=e}}n(r(Error())).toBe(!0),n(r(Error(`hello world!`))).toBe(!0),n(r(new e)).toBe(!1)}),t(`always true`,()=>{e(`regexp`,()=>{n(r(RegExp(``))).toBe(!0),n(r(/abc/u)).toBe(!0)}),e(`dates`,()=>{n(r(new Date(0))).toBe(!0),n(r(new Date)).toBe(!0)}),e(`weak collections`,()=>{n(r(new WeakMap)).toBe(!0),n(r(new WeakSet)).toBe(!0)})})});
-//# sourceMappingURL=is-emptyish.test.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-emptyish.test.js","names":["object: { key?: string }","#a"],"sources":["../src/is-emptyish.test.ts"],"sourcesContent":["/* eslint-disable node/prefer-global/buffer */\nimport { describe, expect, it } from 'vitest';\nimport { isEmptyish } from './is-emptyish';\n\ndescribe('nullish', () => {\n  it('null', () => {\n    expect(isEmptyish(null)).toBe(true);\n  });\n\n  it('undefined', () => {\n    expect(isEmptyish(undefined)).toBe(true);\n  });\n});\n\ndescribe('strings', () => {\n  it('literals', () => {\n    expect(isEmptyish('')).toBe(true);\n    expect(isEmptyish('test')).toBe(false);\n  });\n\n  it('boxed', () => {\n    // eslint-disable-next-line no-new-wrappers, sonar/no-primitive-wrappers\n    expect(isEmptyish(new String(''))).toBe(true);\n    // eslint-disable-next-line no-new-wrappers, sonar/no-primitive-wrappers\n    expect(isEmptyish(new String('test'))).toBe(false);\n  });\n});\n\ndescribe('arrays', () => {\n  it('simple', () => {\n    expect(isEmptyish([])).toBe(true);\n    expect(isEmptyish([1, 2, 3])).toBe(false);\n  });\n\n  it('sparse', () => {\n    // eslint-disable-next-line no-sparse-arrays\n    expect(isEmptyish([, ,])).toBe(false);\n  });\n\n  it('via Array.from', () => {\n    expect(isEmptyish(Array.from({ length: 0 }))).toBe(true);\n    expect(isEmptyish(Array.from({ length: 10 }))).toBe(false);\n  });\n\n  it('typed arrays', () => {\n    expect(isEmptyish(new Int8Array())).toBe(true);\n    expect(isEmptyish(new Int8Array([1, 2, 3]))).toBe(false);\n  });\n\n  it('buffers', () => {\n    expect(isEmptyish(Buffer.alloc(0))).toBe(true);\n    expect(isEmptyish(Buffer.alloc(3))).toBe(false);\n  });\n\n  it('sets', () => {\n    expect(isEmptyish(new Set())).toBe(true);\n    expect(isEmptyish(new Set([1, 2, 3]))).toBe(false);\n  });\n\n  it('array-like (e.g., `arguments`)', () => {\n    function empty(): void {\n      // eslint-disable-next-line prefer-rest-params\n      expect(isEmptyish(arguments)).toBe(true);\n    }\n    empty();\n\n    function nonEmpty(_p0: string, _p1: number, _p2: boolean): void {\n      // eslint-disable-next-line prefer-rest-params\n      expect(isEmptyish(arguments)).toBe(false);\n    }\n    nonEmpty('test', 123, true);\n  });\n});\n\ndescribe('keyed collections', () => {\n  it('plain objects', () => {\n    expect(isEmptyish({})).toBe(true);\n    expect(isEmptyish({ key: 'value' })).toBe(false);\n  });\n\n  it('null-prototyped objects', () => {\n    const object: { key?: string } = Object.create(null);\n\n    expect(isEmptyish(object)).toBe(true);\n\n    object.key = 'hello, world!';\n\n    expect(isEmptyish(object)).toBe(false);\n  });\n\n  it('symbol props', () => {\n    expect(isEmptyish({ [Symbol('hello')]: 'world' })).toBe(false);\n  });\n\n  it('maps', () => {\n    expect(isEmptyish(new Map())).toBe(true);\n    expect(isEmptyish(new Map([['key', 'value']]))).toBe(false);\n  });\n\n  it('url search params', () => {\n    expect(isEmptyish(new URLSearchParams())).toBe(true);\n    expect(isEmptyish(new URLSearchParams(''))).toBe(true);\n    expect(isEmptyish(new URLSearchParams('?'))).toBe(true);\n    expect(isEmptyish(new URLSearchParams('hello'))).toBe(false);\n    expect(isEmptyish(new URLSearchParams({ hello: 'world ' }))).toBe(false);\n  });\n\n  it('prototype chains', () => {\n    // Verifying chained prototypes would add complexity the implementation and\n    // incur performance costs, and the real-life practical use for such a chain\n    // is minimal.\n\n    expect(isEmptyish(Object.create(Object.create({})))).toBe(true);\n\n    expect(isEmptyish(Object.create(Object.create({ a: 123 })))).toBe(false);\n  });\n});\n\ndescribe('self-declared sizes', () => {\n  it('length', () => {\n    expect(isEmptyish({ length: 0 })).toBe(true);\n    expect(isEmptyish({ length: 1 })).toBe(false);\n  });\n\n  it('size', () => {\n    expect(isEmptyish({ size: 0 })).toBe(true);\n    expect(isEmptyish({ size: 1 })).toBe(false);\n  });\n\n  it('props are not coerced', () => {\n    expect(isEmptyish({ length: '0' })).toBe(false);\n    expect(isEmptyish({ size: null })).toBe(false);\n  });\n\n  it('length has precedence over size', () => {\n    expect(isEmptyish({ length: 0, size: 5 })).toBe(true);\n    expect(isEmptyish({ length: 1, size: 0 })).toBe(false);\n  });\n});\n\ndescribe('unsupported types', () => {\n  // Most assertions in this section return the wrong value semantically and are\n  // here to document the expected outputs in those cases for the current\n  // implementation. If any of these break due to a change in the runtime\n  // implementation they should be fixed and possibly extracted out of this\n  // section!\n\n  describe('always false', () => {\n    // Empty !== Falsy...\n\n    it('numbers', () => {\n      expect(isEmptyish(0)).toBe(false);\n      expect(isEmptyish(-0)).toBe(false);\n      expect(isEmptyish(Number.NaN)).toBe(false);\n      expect(isEmptyish(Infinity)).toBe(false);\n      expect(isEmptyish(100)).toBe(false);\n      expect(isEmptyish(12.34)).toBe(false);\n    });\n\n    it('bigints', () => {\n      expect(isEmptyish(0n)).toBe(false);\n      expect(isEmptyish(1n)).toBe(false);\n    });\n\n    it('booleans', () => {\n      expect(isEmptyish(false)).toBe(false);\n      expect(isEmptyish(true)).toBe(false);\n    });\n\n    it('symbols', () => {\n      // Using an empty string in a symbol results in the same \"kind\" of\n      // symbol as ones created with a non-empty string. It's unlikely that the\n      // actual value of a symbol would be checked (and not its identity), and\n      // that that value would be checked for emptiness explicitly.\n\n      expect(isEmptyish(Symbol(''))).toBe(false);\n      expect(isEmptyish(Symbol('something'))).toBe(false);\n    });\n\n    it('functions', () => {\n      // It's not possible to check the contents of a function at runtime, and\n      // even if it were, there's a semantic difference between a purely empty\n      // function and one that doesn't do anything useful (but can still log,\n      // for example).\n\n      expect(isEmptyish(() => {})).toBe(false);\n      expect(\n        isEmptyish(() => {\n          // eslint-disable-next-line no-console\n          console.log('hello');\n        }),\n      ).toBe(false);\n    });\n  });\n\n  it('classes', () => {\n    // It's hard to define what an empty class is; does it have private members?\n    // are we considering it empty if one of it's fields is empty?\n\n    // eslint-disable-next-line ts/no-extraneous-class\n    class Empty {}\n    class NonEmpty {\n      public a = 'hello';\n    }\n    class NonEmptyButPrivate {\n      readonly #a = 'hello';\n\n      public get a(): string {\n        return this.#a;\n      }\n    }\n    class ContainerWrapper {\n      public data: Array<unknown> = [];\n    }\n\n    expect(isEmptyish(new Empty())).toBe(true);\n    expect(isEmptyish(new NonEmpty())).toBe(false);\n    expect(isEmptyish(new NonEmptyButPrivate())).toBe(true);\n    expect(isEmptyish(new ContainerWrapper())).toBe(false);\n  });\n\n  it('errors', () => {\n    // Errors are just classes! We don't special-case errors to check the length\n    // of the message because errors could be designed so that the message is\n    // not important and they hold information in other properties, and they\n    // wouldn't be semantically empty because of that.\n\n    class MyError extends Error {\n      public constructor(public data = 'hello') {\n        super();\n      }\n    }\n\n    // eslint-disable-next-line unicorn/error-message\n    expect(isEmptyish(new Error())).toBe(true);\n    expect(isEmptyish(new Error('hello world!'))).toBe(true);\n    expect(isEmptyish(new MyError())).toBe(false);\n  });\n\n  describe('always true', () => {\n    // These are built-in classes that would be assessed the same way we\n    // assess objects; for the most part they come up as empty because they\n    // don't have any public properties. We don't special-case them for\n    // performance reasons (they would add redundant checks).\n\n    it('regexp', () => {\n      // There is no value in an empty regexp because it catches nothing so it's\n      // unlikely that this would be needed.\n\n      // eslint-disable-next-line prefer-regex-literals, sonar/no-empty-group\n      expect(isEmptyish(new RegExp(''))).toBe(true);\n      expect(isEmptyish(/abc/u)).toBe(true);\n    });\n\n    it('dates', () => {\n      // Dates are wrapped numbers, even if we special-case them there is no\n      // clear semantic for what an \"empty\" date would be.\n\n      expect(isEmptyish(new Date(0))).toBe(true);\n      expect(isEmptyish(new Date())).toBe(true);\n    });\n\n    it('weak collections', () => {\n      // Weak collections don't have a mechanism that allows tracking its size\n      // or enumerating its entries.\n\n      expect(isEmptyish(new WeakMap())).toBe(true);\n      expect(isEmptyish(new WeakSet())).toBe(true);\n    });\n  });\n});\n"],"mappings":"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"}

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-error.d.cts","names":[],"sources":["../src/is-error.ts"],"sourcesContent":[],"mappings":";KAAK,qBACD,QAAQ,GAAG,uBAAuB,QAAQ,QAAQ,GAAG;;;;;;;;;;AAazD;;;AAAqE,iBAArD,OAAqD,CAAA,CAAA,CAAA,CAAA,IAAA,EAApC,KAAoC,GAA5B,CAA4B,CAAA,EAAA,IAAA,IAAhB,eAAgB,CAAA,CAAA,CAAA"}

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-error.d.ts","names":[],"sources":["../src/is-error.ts"],"sourcesContent":[],"mappings":";KAAK,qBACD,QAAQ,GAAG,uBAAuB,QAAQ,QAAQ,GAAG;;;;;;;;;;AAazD;;;AAAqE,iBAArD,OAAqD,CAAA,CAAA,CAAA,CAAA,IAAA,EAApC,KAAoC,GAA5B,CAA4B,CAAA,EAAA,IAAA,IAAhB,eAAgB,CAAA,CAAA,CAAA"}

package/dist/is-function.d.cts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-function.d.cts","names":[],"sources":["../src/is-function.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;;;;;;;;;;iBAAgB,oBAAoB,iBAAiB,YAAY,WAAW,GAAG"}

package/dist/is-function.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-function.d.ts","names":[],"sources":["../src/is-function.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;;;;;;;;;;iBAAgB,oBAAoB,iBAAiB,YAAY,WAAW,GAAG"}

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

@@ -1,109 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
-import { IsLiteral, IsUnion } 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.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in.d.cts","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":[],"mappings":";;;;;;;AAC6E;;;;;;;;;AAoBtD;;KALlB,eAsC0B,CAAA,UAtCA,iBAsCA,CAAA,GAtCqB,CAsCrB,SAAA,SAAA,EAAA,GAAA,IAAA,GApC3B,CAoC2B,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAnCzB,OAmCyB,CAnCjB,IAmCiB,CAAA,SAAA,IAAA,GAAA,KAAA,GAjCvB,eAiCuB,CAjCP,IAiCO,CAAA,GAAA,KAAA;;;;;;;;AAwC/B;;;;;;;;;;AAIA;;;;;;AAgCA;;;;;;;KA5EK,YA8EK,CAAA,CAAA,EAAA,UA9EqB,iBA8ErB,CA9EuC,CA8EvC,CAAA,CAAA,GA7EN,SA6EM,CA7EI,CA6EJ,CAAA,SAAA,IAAA,GArEJ,eAqEI,CArEY,CAqEZ,CAAA,GAjEJ,SAiEI,CAjEM,CAiEN,CAAA,MAAA,CAAA,CAAA;;;AACV;;;;;;;;;;;;;;;;;;;;;;;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.d.ts

@@ -1,109 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
-import { IsLiteral, IsUnion } 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.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-included-in.d.ts","names":[],"sources":["../src/is-included-in.ts"],"sourcesContent":[],"mappings":";;;;;;;AAC6E;;;;;;;;;AAoBtD;;KALlB,eAsC0B,CAAA,UAtCA,iBAsCA,CAAA,GAtCqB,CAsCrB,SAAA,SAAA,EAAA,GAAA,IAAA,GApC3B,CAoC2B,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAnCzB,OAmCyB,CAnCjB,IAmCiB,CAAA,SAAA,IAAA,GAAA,KAAA,GAjCvB,eAiCuB,CAjCP,IAiCO,CAAA,GAAA,KAAA;;;;;;;;AAwC/B;;;;;;;;;;AAIA;;;;;;AAgCA;;;;;;;KA5EK,YA8EK,CAAA,CAAA,EAAA,UA9EqB,iBA8ErB,CA9EuC,CA8EvC,CAAA,CAAA,GA7EN,SA6EM,CA7EI,CA6EJ,CAAA,SAAA,IAAA,GArEJ,eAqEI,CArEY,CAqEZ,CAAA,GAjEJ,SAiEI,CAjEM,CAiEN,CAAA,MAAA,CAAA,CAAA;;;AACV;;;;;;;;;;;;;;;;;;;;;;;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.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.d.cts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-not.d.cts","names":[],"sources":["../src/is-not.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;AAGA;;;iBAHgB,mBAAmB,qBACf,cAAc,WACxB,cAAc,QAAQ,GAAG;iBACnB,2BAA2B,uBAAuB"}

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"is-not.d.ts","names":[],"sources":["../src/is-not.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;;;;AAGA;;;iBAHgB,mBAAmB,qBACf,cAAc,WACxB,cAAc,QAAQ,GAAG;iBACnB,2BAA2B,uBAAuB"}

package/dist/is-nullish.d.cts

@@ -1,23 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.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.d.cts.map

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

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

package/dist/is-nullish.d.ts

@@ -1,23 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.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.d.ts.map

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

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

package/dist/is-number.d.cts

@@ -1,22 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.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.d.cts.map

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

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

package/dist/is-number.d.ts

@@ -1,22 +0,0 @@
-import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.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.d.ts.map

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

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