inferred-types 0.52.14 → 0.53.0

package/dist/types/boolean-logic/operators/AreSameLength.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AreSameLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AreSameLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,OAAO,EACP,eAAe,EACf,OAAO,EACR,MAAM,sBAAsB,CAAC;AAI9B;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,MAAM,GAAG,SAAS,OAAO,EAAE,EACrC,CAAC,SAAS,MAAM,GAAG,SAAS,OAAO,EAAE,IACnC,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GACjC,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GACrE,OAAO,GACP,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACnB,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,GACjC,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,GACnE,OAAO,GACf,OAAO,CAAC"}

package/dist/types/boolean-logic/operators/AreSameLength.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/AreSameType.d.ts

@@ -1,18 +0,0 @@
-import { Widen } from "inferred-types/types";
-/**
- * **AreSameType**`<A,B>`
- *
- * Tests whether `A` and `B` are the same _wide_ type.
- *
- * - Note: for containers, the types are rolled up to the broad category of
- * container (e.g., Dictionary, Tuple, Map, Set, WeakMap)
- *
- * ```ts
- * // true
- * AreSameType<"foo","bar">;
- * // false
- * AreSameType<"foo",42>;
- * ```
- */
-export type AreSameType<A, B> = Widen<A, true> extends Widen<B, true> ? Widen<B, true> extends Widen<A, true> ? true : false : false;
-//# sourceMappingURL=AreSameType.d.ts.map

package/dist/types/boolean-logic/operators/AreSameType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AreSameType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AreSameType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAC,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAClE,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GACnC,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/AreSameType.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/Contains.d.ts

@@ -1,26 +0,0 @@
-import { IsWideType, Or, TupleToUnion } from "inferred-types/types";
-export type ToStringLiteral = string | number | boolean;
-type ProcessStr<TContent extends string, TComparator> = IsWideType<TComparator> extends true ? boolean : TComparator extends readonly ToStringLiteral[] ? ProcessStr<TContent, TupleToUnion<TComparator>> : TComparator extends ToStringLiteral ? TContent extends `${string}${TComparator}${string}` ? true : false : false;
-/**
- * Processes each node of the tuple
- * and then `or` the result to reach
- * single consensus
- */
-type ProcessTuple<TContent extends readonly unknown[], TComparator> = Or<{
-    [K in keyof TContent]: [TContent[K]] extends [TComparator] ? true : false;
-}>;
-type PreProcess<TContent, TComparator> = TContent extends readonly unknown[] ? TComparator extends readonly unknown[] ? ProcessTuple<TContent, TupleToUnion<TComparator>> : ProcessTuple<TContent, TComparator> : TContent extends ToStringLiteral ? TComparator extends readonly unknown[] ? ProcessStr<`${TContent}`, TupleToUnion<TComparator>> : ProcessStr<`${TContent}`, TComparator> : never;
-/**
- * **Contains**`<TContent, TComparator>`
- *
- * Checks whether `TContent` _contains_ a value of `TComparator`:
- *
- * - when `TContent` is an array/tuple type then each item is compared to `TComparator`
- * - if `TContent` is a string or numeric type then it will report on whether `TComparator`
- * has been found as a string subset
- *
- * **Related:** `NarrowlyContains`
- */
-export type Contains<TContent extends string | number | readonly unknown[], TComparator> = [IsWideType<TContent>] extends [true] ? boolean : PreProcess<TContent, TComparator>;
-export {};
-//# sourceMappingURL=Contains.d.ts.map

package/dist/types/boolean-logic/operators/Contains.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Contains.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Contains.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,EAAE,EACF,YAAY,EACb,MAAM,sBAAsB,CAAC;AAG9B,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAKxD,KAAK,UAAU,CACb,QAAQ,SAAS,MAAM,EACvB,WAAW,IACT,UAAU,CAAC,WAAW,CAAC,SAAS,IAAI,GACpC,OAAO,GACP,WAAW,SAAS,SAAS,eAAe,EAAE,GAC5C,UAAU,CAAC,QAAQ,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,GACjD,WAAW,SAAS,eAAe,GACjC,QAAQ,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,EAAE,GACjD,IAAI,GACJ,KAAK,GACP,KAAK,CAAC;AAGZ;;;;GAIG;AACH,KAAK,YAAY,CACf,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,IACT,EAAE,CAAC;KACJ,CAAC,IAAI,MAAM,QAAQ,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,GACtD,IAAI,GACJ,KAAK;CACV,CAAC,CAAC;AAKH,KAAK,UAAU,CACb,QAAQ,EACR,WAAW,IAEb,QAAQ,SAAS,SAAS,OAAO,EAAE,GACjC,WAAW,SAAS,SAAS,OAAO,EAAE,GACpC,YAAY,CAAC,QAAQ,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,GACjD,YAAY,CAAC,QAAQ,EAAE,WAAW,CAAC,GACrC,QAAQ,SAAS,eAAe,GAC9B,WAAW,SAAS,SAAS,OAAO,EAAE,GACpC,UAAU,CAAC,GAAG,QAAQ,EAAE,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,GACpD,UAAU,CAAC,GAAG,QAAQ,EAAE,EAAE,WAAW,CAAC,GAC1C,KAAK,CAAC;AAGR;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,CAClB,QAAQ,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,OAAO,EAAE,EACrD,WAAW,IACT,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACnC,OAAO,GACP,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/Contains.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/ContainsAll.d.ts

@@ -1,17 +0,0 @@
-import { And, Contains, Narrowable, AfterFirst, First } from "inferred-types/types";
-type _Contains<TList extends readonly unknown[], THasAll extends Narrowable[], TResults extends readonly boolean[] = []> = [] extends THasAll ? TResults : Contains<TList, First<THasAll>> extends true ? _Contains<TList, AfterFirst<THasAll>, [
-    ...TResults,
-    true
-]> : [false];
-/**
-  * **ContainsAll**`<TList, THasAll>`
-  *
-  * Type utility which provides a boolean response based on
-  * whether the list `TList` contains _all_ of the values passed
-  * in.
-  *
-  * **Related:** `DoesExtend`, `ContainsSome`
-  */
-export type ContainsAll<TList extends readonly unknown[], THasAll extends Narrowable[]> = And<_Contains<TList, THasAll>>;
-export {};
-//# sourceMappingURL=ContainsAll.d.ts.map

package/dist/types/boolean-logic/operators/ContainsAll.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ContainsAll.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ContainsAll.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAG,UAAU,EAAG,UAAU,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGtF,KAAK,SAAS,CACd,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,SAAS,UAAU,EAAE,EAC5B,QAAQ,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACpC,EAAE,SAAS,OAAO,GAClB,QAAQ,GACR,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,SAAS,IAAI,GAC1C,SAAS,CACT,KAAK,EACL,UAAU,CAAC,OAAO,CAAC,EACnB;IAAC,GAAG,QAAQ;IAAE,IAAI;CAAC,CACpB,GACC,CAAC,KAAK,CAAC,CAAC;AAEd;;;;;;;;IAQI;AACJ,MAAM,MAAM,WAAW,CACrB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,SAAS,UAAU,EAAE,IAC1B,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/ContainsAll.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/DoesExtend.d.ts

@@ -1,8 +0,0 @@
-import { IsNever } from "inferred-types/types";
-/**
- * **DoesExtend**`<TValue, TExtends>`
- *
- * Boolean type utility which returns `true` if `TValue` _extends_ `TExtends`.
- */
-export type DoesExtend<TValue, TExtends> = IsNever<TValue> extends true ? false : [TValue] extends [TExtends] ? true : false;
-//# sourceMappingURL=DoesExtend.d.ts.map

package/dist/types/boolean-logic/operators/DoesExtend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DoesExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/DoesExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C;;;;GAIG;AACH,MAAM,MAAM,UAAU,CACpB,MAAM,EACN,QAAQ,IACN,OAAO,CAAC,MAAM,CAAC,SAAS,IAAI,GAC5B,KAAK,GACL,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,GACzB,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/DoesExtend.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/DoesNotExtend.d.ts

@@ -1,8 +0,0 @@
-/**
- * **DoesNotExtend**`<TValue, TNotExtends>`
- *
- * Boolean type utility which returns `true` if `TValue` _does
- * not extend_ `TNotExtends`.
- */
-export type DoesNotExtend<TValue, TNotExtends> = TValue extends TNotExtends ? false : true;
-//# sourceMappingURL=DoesNotExtend.d.ts.map

package/dist/types/boolean-logic/operators/DoesNotExtend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DoesNotExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/DoesNotExtend.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACzB,MAAM,EACN,WAAW,IACP,MAAM,SAAS,WAAW,GAC5B,KAAK,GACL,IAAI,CAAC"}

package/dist/types/boolean-logic/operators/DoesNotExtend.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/EndsWith.d.ts

@@ -1,21 +0,0 @@
-import { AsString, IsStringLiteral, Or } from "inferred-types/types";
-type Test<TValue extends string, TComparator extends string> = TValue extends `${string}${TComparator}` ? true : false;
-type Process<TValue extends string, TComparator extends string> = IsStringLiteral<TComparator> extends true ? IsStringLiteral<TValue> extends true ? Test<TValue, TComparator> : boolean : boolean;
-type ProcessEach<TValue extends string, TComparator extends readonly string[]> = Or<{
-    [K in keyof TComparator]: Process<TValue, TComparator[K]>;
-}>;
-type PreProcess<TValue extends string, TComparator extends string | readonly string[]> = TComparator extends readonly string[] ? ProcessEach<TValue, TComparator> : TComparator extends string ? Process<TValue, TComparator> : never;
-/**
- * **EndsWith**<TValue, TComparator>
- *
- * A type utility which checks whether `TValue` _ends with_ the
- * value of `TComparator`.
- *
- * - numeric values for `TValue` will be converted into string literals
- * prior to comparison
- * - a tuple value in `TComparator` is allowed and will test whether
- * _at least one_ type Ends the sequence for TValue
- */
-export type EndsWith<TValue extends string | number, TComparator extends string | number | readonly string[]> = PreProcess<AsString<TValue>, TComparator extends number ? AsString<TComparator> : TComparator>;
-export {};
-//# sourceMappingURL=EndsWith.d.ts.map

package/dist/types/boolean-logic/operators/EndsWith.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EndsWith.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/EndsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,QAAQ,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAEtE,KAAK,IAAI,CACP,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,IACxB,MAAM,SAAS,GAAG,MAAM,GAAG,WAAW,EAAE,GAC1C,IAAI,GACJ,KAAK,CAAC;AAER,KAAK,OAAO,CACV,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,IACxB,eAAe,CAAC,WAAW,CAAC,SAAS,IAAI,GACzC,eAAe,CAAC,MAAM,CAAC,SAAS,IAAI,GAClC,IAAI,CAAC,MAAM,EAAC,WAAW,CAAC,GACxB,OAAO,GACT,OAAO,CAAC;AAEZ,KAAK,WAAW,CACZ,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,SAAS,MAAM,EAAE,IACrC,EAAE,CAAC;KACJ,CAAC,IAAI,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,EAAC,WAAW,CAAC,CAAC,CAAC,CAAC;CACzD,CAAC,CAAC;AAGH,KAAK,UAAU,CACb,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,IAC5C,WAAW,SAAS,SAAS,MAAM,EAAE,GACrC,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,GAChC,WAAW,SAAS,MAAM,GACtB,OAAO,CAAC,MAAM,EAAC,WAAW,CAAC,GAC3B,KAAK,CAAC;AAEd;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,CAClB,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,IACrD,UAAU,CACZ,QAAQ,CAAC,MAAM,CAAC,EAChB,WAAW,SAAS,MAAM,GACtB,QAAQ,CAAC,WAAW,CAAC,GACrB,WAAW,CAChB,CAAC"}

package/dist/types/boolean-logic/operators/EndsWith.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/Extends.d.ts

@@ -1,10 +0,0 @@
-import { DoesExtend } from "./DoesExtend";
-import { IsNever } from "./IsNever";
-/**
- * **Extends**`<T,U>`
- *
- * A boolean operator which checks whether `T` extends `U` and returns
- * **true** or **false**. This is an _alias_ for `DoesExtend`.
- */
-export type Extends<T, U> = IsNever<T> extends true ? IsNever<U> extends true ? true : false : DoesExtend<T, U>;
-//# sourceMappingURL=Extends.d.ts.map

package/dist/types/boolean-logic/operators/Extends.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Extends.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Extends.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAChD,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,IAAI,GACJ,KAAK,GACP,UAAU,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/Extends.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/ExtendsAll.d.ts

@@ -1,13 +0,0 @@
-import type { And } from "inferred-types/types";
-type _Extends<TValue, TList extends readonly unknown[], Processed extends readonly boolean[] = []> = TList extends [infer First, ...infer Rest] ? First extends TValue ? _Extends<TValue, Rest, readonly [...Processed, true]> : _Extends<TValue, Rest, readonly [...Processed, false]> : And<Processed>;
-/**
-  * **ExtendsAll**`<TValue, TList>`
-  *
-  * Boolean type utility which evaluates whether a singular
-  * value `TValue` extends **all** of the elements in `TList`.
-  *
-  * **Related:** `ExtendsSome`, `IfExtendsAll`, `DoesExtend`
-  */
-export type ExtendsAll<TValue, TList extends readonly unknown[]> = _Extends<TValue, TList>;
-export {};
-//# sourceMappingURL=ExtendsAll.d.ts.map

package/dist/types/boolean-logic/operators/ExtendsAll.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExtendsAll.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ExtendsAll.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAGhD,KAAK,QAAQ,CACb,MAAM,EACN,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,SAAS,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACrC,KAAK,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC5C,KAAK,SAAS,MAAM,GAClB,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,SAAS,EAAE,IAAI,CAAC,CAAC,GACrD,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,GAAG,SAAS,EAAE,KAAK,CAAC,CAAC,GACxD,GAAG,CAAC,SAAS,CAAC,CAAC;AAEjB;;;;;;;IAOI;AACJ,MAAM,MAAM,UAAU,CACpB,MAAM,EACN,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/ExtendsAll.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/ExtendsNone.d.ts

@@ -1,11 +0,0 @@
-import type { Not, ExtendsSome } from "inferred-types/types";
-/**
-  * **ExtendsAll**`<TValue, TList>`
-  *
-  * Boolean type utility which evaluates whether a singular
-  * value `TValue` extends **all** of the elements in `TList`.
-  *
-  * **Related:** `ExtendsSome`, `IfExtendsAll`, `DoesExtend`
-  */
-export type ExtendsNone<TValue, TList extends readonly unknown[]> = Not<ExtendsSome<TValue, TList>>;
-//# sourceMappingURL=ExtendsNone.d.ts.map

package/dist/types/boolean-logic/operators/ExtendsNone.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExtendsNone.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ExtendsNone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAG7D;;;;;;;IAOI;AACJ,MAAM,MAAM,WAAW,CACrB,MAAM,EACN,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/ExtendsNone.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/ExtendsSome.d.ts

@@ -1,11 +0,0 @@
-import type { AfterFirst, First } from "inferred-types/types";
-/**
- * **ExtendsSome**`<TValue,TList>`
- *
- * Boolean type utility which evaluates whether `TValue` extends **some** of the
- * elements in `TList`.
- *
- * **Related:** `ExtendsAll`, `IfExtendsSome`, `DoesExtend`
- */
-export type ExtendsSome<TValue, TExtendsSome extends readonly unknown[]> = [] extends TExtendsSome ? false : TValue extends First<TExtendsSome> ? true : ExtendsSome<TValue, AfterFirst<TExtendsSome>>;
-//# sourceMappingURL=ExtendsSome.d.ts.map

package/dist/types/boolean-logic/operators/ExtendsSome.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExtendsSome.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ExtendsSome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CACrB,MAAM,EACN,YAAY,SAAS,SAAS,OAAO,EAAE,IACrC,EAAE,SAAS,YAAY,GACvB,KAAK,GACL,MAAM,SAAS,KAAK,CAAC,YAAY,CAAC,GAChC,IAAI,GACJ,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/ExtendsSome.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasArray.d.ts

@@ -1,10 +0,0 @@
-import { AfterFirst, First, IsArray } from "inferred-types/types";
-type _HasArray<TList extends readonly unknown[]> = [] extends TList ? false : IsArray<First<TList>> extends true ? true : _HasArray<AfterFirst<TList>>;
-/**
- * **HasArray**`<TList>`
- *
- * Checks whether a list of items includes an _array_ (tuple or wide array type) within it.
- */
-export type HasArray<TList extends readonly unknown[]> = _HasArray<TList>;
-export {};
-//# sourceMappingURL=HasArray.d.ts.map

package/dist/types/boolean-logic/operators/HasArray.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasArray.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAG,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEnE,KAAK,SAAS,CACZ,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,SAAS,CAAE,UAAU,CAAC,KAAK,CAAC,CAAE,CAAC;AAErC;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/HasArray.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasCharacters.d.ts

@@ -1,22 +0,0 @@
-import type { IsUnion, UnionToTuple, IsStringLiteral, AllStringLiterals, AsArray, Or, And } from "inferred-types/types";
-type Process<TStr extends string, TChars extends string, _TOp extends "any" | "all"> = TStr extends `${string}${TChars}${string}` ? true : false;
-type ProcessTuple<TStr extends string, TChars extends readonly string[], TOp extends "any" | "all"> = TOp extends "any" ? Or<{
-    [K in keyof TChars]: TStr extends `${string}${TChars[K]}${string}` ? true : false;
-}> : And<{
-    [K in keyof TChars]: TStr extends `${string}${TChars[K]}${string}` ? true : false;
-}>;
-type PreProcess<TStr extends string, TChars extends string, TOp extends "any" | "all"> = IsUnion<TChars> extends true ? UnionToTuple<TChars> extends readonly string[] ? ProcessTuple<TStr, UnionToTuple<TChars>, TOp> : never : Process<TStr, TChars, TOp>;
-/**
- * **HasCharacters**`<TStr,TChars>`
- *
- * Boolean type utility which tests whether `TStr` has _any_ of the
- * characters in `TChars`.
- *
- * - If you would prefer to test for ALL characters matching then
- * you can change `TOp` to "all".
- *
- * **Related:** `NotCharacters`
- */
-export type HasCharacters<TStr extends string, TChars extends string | readonly string[], TOp extends "any" | "all" = "any"> = IsStringLiteral<TStr> extends true ? TChars extends string ? IsStringLiteral<TChars> extends true ? PreProcess<TStr, TChars, TOp> : boolean : TChars extends readonly string[] ? AllStringLiterals<AsArray<TChars>> extends true ? ProcessTuple<TStr, TChars, TOp> : boolean : boolean : boolean;
-export {};
-//# sourceMappingURL=HasCharacters.d.ts.map

package/dist/types/boolean-logic/operators/HasCharacters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasCharacters.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasCharacters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,OAAO,EACP,EAAE,EACF,GAAG,EACJ,MAAM,sBAAsB,CAAC;AAE9B,KAAK,OAAO,CACV,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,EACrB,IAAI,SAAS,KAAK,GAAG,KAAK,IACxB,IAAI,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAC5C,IAAI,GACJ,KAAK,CAAC;AAER,KAAK,YAAY,CACf,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,SAAS,MAAM,EAAE,EAChC,GAAG,SAAS,KAAK,GAAG,KAAK,IACvB,GAAG,SAAS,KAAK,GACnB,EAAE,CAAC;KACF,CAAC,IAAI,MAAM,MAAM,GAAG,IAAI,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,GAC9D,IAAI,GACJ,KAAK;CACV,CAAC,GACA,GAAG,CAAC;KACH,CAAC,IAAI,MAAM,MAAM,GAAG,IAAI,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,GAC9D,IAAI,GACJ,KAAK;CACV,CAAC,CAAC;AAEH,KAAK,UAAU,CACb,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,EACrB,GAAG,SAAS,KAAK,GAAG,KAAK,IACvB,OAAO,CAAC,MAAM,CAAC,SAAS,IAAI,GAC9B,YAAY,CAAC,MAAM,CAAC,SAAS,SAAS,MAAM,EAAE,GAC5C,YAAY,CAAC,IAAI,EAAC,YAAY,CAAC,MAAM,CAAC,EAAC,GAAG,CAAC,GAC3C,KAAK,GACP,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AAG7B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,CACvB,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,EACzC,GAAG,SAAS,KAAK,GAAG,KAAK,GAAG,KAAK,IAC/B,eAAe,CAAC,IAAI,CAAC,SAAS,IAAI,GAClC,MAAM,SAAS,MAAM,GACnB,eAAe,CAAC,MAAM,CAAC,SAAS,IAAI,GAClC,UAAU,CAAC,IAAI,EAAC,MAAM,EAAC,GAAG,CAAC,GAC3B,OAAO,GACX,MAAM,SAAS,SAAS,MAAM,EAAE,GAC9B,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,IAAI,GAC7C,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,GAC/B,OAAO,GACT,OAAO,GAET,OAAO,CAAC"}

package/dist/types/boolean-logic/operators/HasCharacters.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasIndex.d.ts

@@ -1,9 +0,0 @@
-import { Container } from "inferred-types/types";
-/**
- * **HasIndex**`<TContainer, TIdx>`
- *
- * Boolean operator that tests whether `TContainer` has the
- * index value `TIdx`.
- */
-export type HasIndex<TContainer, TIdx extends PropertyKey> = TContainer extends Container ? TIdx extends keyof TContainer ? true : false : false;
-//# sourceMappingURL=HasIndex.d.ts.map

package/dist/types/boolean-logic/operators/HasIndex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasIndex.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACV,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAClB,UAAU,EACV,IAAI,SAAS,WAAW,IACtB,UAAU,SAAS,SAAS,GAC9B,IAAI,SAAS,MAAM,UAAU,GAC3B,IAAI,GACJ,KAAK,GACP,KAAK,CAAA"}

package/dist/types/boolean-logic/operators/HasIndex.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasOtherCharacters.d.ts

@@ -1,16 +0,0 @@
-import type { ReplaceAll, IsWideType, TupleToUnion } from "inferred-types/types";
-type Process<TStr extends string, TChars extends string> = ReplaceAll<TStr, TChars, ""> extends "" ? false : true;
-/**
- * **HasOtherCharacters**`<TStr,TChars>`
- *
- * Boolean type utility which tests whether `TStr` has any
- * characters _other_ than those in `TChars`.
- *
- * - union types are fine for `TChars`
- * - a tuple for `TChars` behaves the same as union type
- *
- * **Related:** `HasCharacters`
- */
-export type HasOtherCharacters<TStr extends string, TChars extends string | readonly string[]> = [IsWideType<TStr>] extends [true] ? boolean : [TChars] extends [string] ? IsWideType<TChars> extends true ? boolean : Process<TStr, TChars> : TChars extends readonly string[] ? Process<TStr, TupleToUnion<TChars>> : never;
-export {};
-//# sourceMappingURL=HasOtherCharacters.d.ts.map

package/dist/types/boolean-logic/operators/HasOtherCharacters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasOtherCharacters.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasOtherCharacters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B,KAAK,OAAO,CACV,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,IACnB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,SAAS,EAAE,GACzC,KAAK,GACL,IAAI,CAAC;AAIP;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,CAC5B,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,IACvC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACnC,OAAO,GACP,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,GACzB,UAAU,CAAC,MAAM,CAAC,SAAS,IAAI,GAC7B,OAAO,GACP,OAAO,CAAC,IAAI,EAAC,MAAM,CAAC,GACtB,MAAM,SAAS,SAAS,MAAM,EAAE,GAC9B,OAAO,CAAC,IAAI,EAAC,YAAY,CAAC,MAAM,CAAC,CAAC,GAClC,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/HasOtherCharacters.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasParameters.d.ts

@@ -1,14 +0,0 @@
-import { Length, IsEqual, TypedFunction } from "inferred-types/types";
-/**
- * **HasParameters**`<T>`
- *
- * Type utility which detects if `T` is both a function and whether that
- * function has at least one type parameter.
- * ```ts
- * const fn = (foo: string) => `${foo}bar`;
- * // true
- * type P = HasParameters<typeof fn>;
- * ```
- */
-export type HasParameters<T> = T extends TypedFunction ? IsEqual<Length<Parameters<T>>, 0> extends true ? false : true : false;
-//# sourceMappingURL=HasParameters.d.ts.map

package/dist/types/boolean-logic/operators/HasParameters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasParameters.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasParameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,MAAM,EAAG,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GAClD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC5C,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/HasParameters.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasProp.d.ts

@@ -1,11 +0,0 @@
-/**
- * **HasProp**<TTest,TProp,[TIf],[TElse]>
- *
- * Boolean operator which returns true or false (by default) based
- * on whether `TTest` has a property defined by `TProp`.
- *
- * If you wish to change the true/false values you can override
- * the `Tif` and `TElse` generics.
- */
-export type HasProp<TTest, TProp extends string, TIf = true, TElse = false> = TTest extends object ? TProp extends keyof TTest ? TIf : TElse : TElse;
-//# sourceMappingURL=HasProp.d.ts.map

package/dist/types/boolean-logic/operators/HasProp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasProp.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasProp.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CACjB,KAAK,EACL,KAAK,SAAS,MAAM,EACpB,GAAG,GAAG,IAAI,EACV,KAAK,GAAG,KAAK,IACX,KAAK,SAAS,MAAM,GACtB,KAAK,SAAS,MAAM,KAAK,GACvB,GAAG,GACH,KAAK,GACP,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/HasProp.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasRequiredProps.d.ts

@@ -1,9 +0,0 @@
-import { ObjectKey, RequiredKeysTuple, AnyObject, IsWideContainer, IsEqual, EmptyObject } from "inferred-types/types";
-/**
- * **HasRequiredProps**`<T>`
- *
- * Receives an object and returns true/false based on whether
- * the type has required properties or not.
- */
-export type HasRequiredProps<T extends AnyObject> = IsWideContainer<T> extends true ? IsEqual<T, EmptyObject> extends true ? false : boolean : RequiredKeysTuple<T> extends readonly ObjectKey[] ? RequiredKeysTuple<T>["length"] extends 0 ? false : true : false;
-//# sourceMappingURL=HasRequiredProps.d.ts.map

package/dist/types/boolean-logic/operators/HasRequiredProps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasRequiredProps.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasRequiredProps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,OAAO,EACP,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,SAAS,IACjB,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GACjC,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,OAAO,GAEtD,iBAAiB,CAAC,CAAC,CAAC,SAAS,SAAS,SAAS,EAAE,GAC/C,iBAAiB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACtC,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/HasRequiredProps.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasSameKeys.d.ts

@@ -1,13 +0,0 @@
-import { And, AsTuple, Container, DoesExtend, HasSameValues, IsTuple, ObjectKey, RemoveIndexKeys, UnionToTuple } from "inferred-types/types";
-type Process<A extends readonly unknown[], B extends readonly unknown[]> = And<{
-    [K in keyof A]: K extends keyof B ? true : false;
-}>;
-type _Keys<T extends object> = UnionToTuple<keyof RemoveIndexKeys<T>> extends readonly ObjectKey[] ? UnionToTuple<keyof RemoveIndexKeys<T>> : never;
-/**
- * **HasSameKeys**`<A,B>`
- *
- * Boolean operator which compares two lists to see if they have the same keys.
- */
-export type HasSameKeys<A extends Container, B extends Container> = IsTuple<A> extends true ? IsTuple<B> extends true ? AsTuple<A>["length"] extends AsTuple<B>["length"] ? Process<AsTuple<A>, AsTuple<B>> : false : false : DoesExtend<A, object> extends true ? DoesExtend<B, object> extends true ? _Keys<A>["length"] extends _Keys<B>["length"] ? HasSameValues<_Keys<A>, _Keys<B>> : false : false : false;
-export {};
-//# sourceMappingURL=HasSameKeys.d.ts.map

package/dist/types/boolean-logic/operators/HasSameKeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasSameKeys.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasSameKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,GAAG,EAAG,OAAO,EAAE,SAAS,EAAE,UAAU,EAAI,aAAa,EAAI,OAAO,EAAE,SAAS,EAAC,eAAe,EAAG,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAIlJ,KAAK,OAAO,CACV,CAAC,SAAS,SAAS,OAAO,EAAE,EAC5B,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B,GAAG,CAAC;KACL,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GAC7B,IAAI,GACJ,KAAK;CACV,CAAC,CAAA;AAEF,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,SAAS,EAAE,GAChG,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,GACtC,KAAK,CAAA;AAIP;;;;GAIG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,SAAS,IAErB,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAC/C,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAC9B,KAAK,GACT,KAAK,GACP,UAAU,CAAC,CAAC,EAAC,MAAM,CAAC,SAAS,IAAI,GAC/B,UAAU,CAAC,CAAC,EAAC,MAAM,CAAC,SAAS,IAAI,GAC/B,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAC3C,aAAa,CAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAClC,KAAK,GACP,KAAK,GACP,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/HasSameKeys.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasSameValues.d.ts

@@ -1,19 +0,0 @@
-import { And, Dictionary, If, IsNever, Or, Values } from "inferred-types/types";
-type Find<TList extends readonly unknown[], TComparator> = Or<{
-    [K in keyof TList]: [TList[K]] extends [TComparator] ? true : false;
-}>;
-type Compare<TList extends readonly unknown[], TComparator extends readonly unknown[]> = And<{
-    [K in keyof TList]: Find<TComparator, TList[K]> extends boolean ? Find<TComparator, TList[K]> : never;
-}, true>;
-type Process<TList extends readonly unknown[], TComparator extends readonly unknown[]> = TList["length"] extends TComparator["length"] ? Compare<TList, TComparator> : false;
-type _HasSameValues<TContainer extends readonly unknown[], TComparator extends readonly unknown[]> = TContainer extends readonly unknown[] ? Process<TContainer, TComparator> : TContainer extends Dictionary ? Process<Values<TContainer>, TComparator> : never;
-/**
- * **HasSameValues**`<TContainer,TComparator>`
- *
- * Boolean type utility which determines if the values in
- * `TList` and `TComparator` are the same (even if the order
- * is different).
- */
-export type HasSameValues<TContainer extends readonly unknown[], TComparator extends readonly unknown[]> = If<IsNever<TContainer>, If<IsNever<TComparator>, true, false>, If<IsNever<TComparator>, false, _HasSameValues<TContainer, TComparator>>>;
-export {};
-//# sourceMappingURL=HasSameValues.d.ts.map

package/dist/types/boolean-logic/operators/HasSameValues.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasSameValues.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasSameValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEhF,KAAK,IAAI,CACP,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,WAAW,IACT,EAAE,CAAC;KACJ,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,IAAI,GAAG,KAAK;CACpE,CAAC,CAAC;AAEH,KAAK,OAAO,CACV,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,WAAW,SAAS,SAAS,OAAO,EAAE,IACpC,GAAG,CAAC;KACL,CAAC,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,GAC3D,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAC3B,KAAK;CACV,EAAE,IAAI,CAAC,CAAA;AAER,KAAK,OAAO,CACZ,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,WAAW,SAAS,SAAS,OAAO,EAAE,IAClC,KAAK,CAAC,QAAQ,CAAC,SAAS,WAAW,CAAC,QAAQ,CAAC,GAC/C,OAAO,CACP,KAAK,EACL,WAAW,CACZ,GACC,KAAK,CAAC;AAGR,KAAK,cAAc,CACnB,UAAU,SAAS,SAAS,OAAO,EAAE,EACrC,WAAW,SAAS,SAAS,OAAO,EAAE,IAClC,UAAU,SAAS,SAAS,OAAO,EAAE,GACvC,OAAO,CAAC,UAAU,EAAC,WAAW,CAAC,GAC/B,UAAU,SAAS,UAAU,GAC7B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,EAAC,WAAW,CAAC,GACvC,KAAK,CAAC;AAER;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,CACvB,UAAU,SAAS,SAAS,OAAO,EAAE,EACrC,WAAW,SAAS,SAAS,OAAO,EAAE,IACpC,EAAE,CACJ,OAAO,CAAC,UAAU,CAAC,EACnB,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,EACrC,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,UAAU,EAAC,WAAW,CAAC,CAAC,CACxE,CAAA"}

package/dist/types/boolean-logic/operators/HasSameValues.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasUnionType.d.ts

@@ -1,10 +0,0 @@
-import { AfterFirst, First, IsUnion } from "inferred-types/types";
-type _HasUnion<TList extends readonly unknown[]> = [] extends TList ? false : IsUnion<First<TList>> extends true ? true : _HasUnion<AfterFirst<TList>>;
-/**
- * **HasUnionType**`<TList>`
- *
- * Checks whether a list of items includes a value in it which is a _union type_.
- */
-export type HasUnionType<TList extends readonly unknown[]> = _HasUnion<TList>;
-export {};
-//# sourceMappingURL=HasUnionType.d.ts.map

package/dist/types/boolean-logic/operators/HasUnionType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasUnionType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasUnionType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAG,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEnE,KAAK,SAAS,CACZ,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,IAAI,GAC9B,IAAI,GACJ,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;AAErC;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/HasUnionType.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HasWideValues.d.ts

@@ -1,10 +0,0 @@
-import { AfterFirst, First, IsWideType } from "inferred-types/types";
-type Validate<T extends readonly unknown[]> = [] extends T ? false : IsWideType<First<T>> extends true ? true : Validate<AfterFirst<T>>;
-/**
- * **HasWideValues**`<T>`
- *
- * Tests whether any values in the tuple are _wide_ (aka, not a literal) value.
- */
-export type HasWideValues<T extends readonly unknown[]> = Validate<T>;
-export {};
-//# sourceMappingURL=HasWideValues.d.ts.map

package/dist/types/boolean-logic/operators/HasWideValues.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HasWideValues.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasWideValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAErE,KAAK,QAAQ,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,GACxD,KAAK,GACL,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/B,IAAI,GACJ,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAE5B;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/HasWideValues.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/HaveSameNumericSign.d.ts

@@ -1,9 +0,0 @@
-import { If, NumberLike, IsNegativeNumber, IsPositiveNumber } from "inferred-types/types";
-/**
- * **HaveSameNumericSign**`<A,B>`
- *
- * Validates that `A` _and_ `B` are both negative number or both
- * positive numbers.
- */
-export type HaveSameNumericSign<A extends NumberLike, B extends NumberLike> = If<IsPositiveNumber<A>, IsPositiveNumber<B> extends true ? true : false, IsNegativeNumber<B> extends true ? true : false>;
-//# sourceMappingURL=HaveSameNumericSign.d.ts.map

package/dist/types/boolean-logic/operators/HaveSameNumericSign.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HaveSameNumericSign.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HaveSameNumericSign.ts"],"names":[],"mappings":"AACA,OAAO,EACL,EAAE,EACF,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,CAC7B,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,UAAU,IAClB,EAAE,CACJ,gBAAgB,CAAC,CAAC,CAAC,EACnB,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,EAC/C,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAChD,CAAA"}

package/dist/types/boolean-logic/operators/HaveSameNumericSign.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/IsAllCaps.d.ts

@@ -1,21 +0,0 @@
-/**
- * **IsAllCaps**`<T>
- *
- * Boolean operator which returns _true_ when `T` consists of ALL capital letters.
- *
- * - Note: non-alphabetic characters are ignored by this utility
- *
- * ```ts
- * // true
- * type T = AllCaps<"FOOBAR">;
- * type T2 = AllCaps<"FOOBAR2">;
- * // false
- * type T = AllCaps<"FooBar">;
- * // boolean
- * type T = AllCaps<string>;
- * ```
- *
- * **Related:** `IsAllLowercase`
- */
-export type IsAllCaps<T extends string> = string extends T ? boolean : T extends Uppercase<T> ? true : false;
-//# sourceMappingURL=IsAllCaps.d.ts.map

package/dist/types/boolean-logic/operators/IsAllCaps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsAllCaps.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAllCaps.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,SAAS,CAAC,GACtD,OAAO,GACP,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsAllCaps.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/IsAllLowercase.d.ts

@@ -1,20 +0,0 @@
-import { UpperAlphaChar, If, HasCharacters } from "inferred-types/types";
-/**
- * **IsAllLowercase**`<T>`
- *
- * Boolean operator which indicates whether `T` has _all_ lowercase characters in it.
- * Valid values are:
- *
- * - note: any non-alphabetic characters are ignored in the evaluation
- *
- * ```ts
- * // true
- * type T = AllCaps<"foobar">;
- * // false
- * type T = AllCaps<"FooBar">;
- * // boolean
- * type T = AllCaps<string>;
- * ```
- */
-export type IsAllLowercase<T extends string> = string extends T ? boolean : If<HasCharacters<T, UpperAlphaChar>, true, false>;
-//# sourceMappingURL=IsAllLowercase.d.ts.map

package/dist/types/boolean-logic/operators/IsAllLowercase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsAllLowercase.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAllLowercase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,EAAE,EAAC,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,SAAS,CAAC,GAC3D,OAAO,GACP,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,cAAc,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC"}

package/dist/types/boolean-logic/operators/IsAllLowercase.js

@@ -1 +0,0 @@
-export {};

package/dist/types/boolean-logic/operators/IsAny.d.ts

@@ -1,8 +0,0 @@
-import { IsNever } from "inferred-types/types";
-/**
- * **IsAny**`<T>`
- *
- * Tests whether a given `T` is of the **any** type.
- */
-export type IsAny<T> = IsNever<T> extends true ? false : 1 extends T & 0 ? true : false;
-//# sourceMappingURL=IsAny.d.ts.map

package/dist/types/boolean-logic/operators/IsAny.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IsAny.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAny.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAC5C,KAAK,GACL,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/dist/types/boolean-logic/operators/IsAny.js

@@ -1 +0,0 @@
-export {};