inferred-types 0.51.0 → 0.51.2

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

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

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

@@ -0,0 +1,18 @@
+import { Widen } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"version":3,"file":"AreSameType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AreSameType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAExD;;;;;;;;;;;;;;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

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

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

@@ -0,0 +1,26 @@
+import { IsWideType, Or, TupleToUnion } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAGzC,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

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

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

@@ -0,0 +1,17 @@
+import { And, Contains, Narrowable, AfterFirst, First } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAGjG,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

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

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

@@ -0,0 +1,8 @@
+import { IsNever } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"version":3,"file":"DoesExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/DoesExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAE1D;;;;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

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

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

@@ -0,0 +1,8 @@
+/**
+ * **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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,21 @@
+import { AsString, IsStringLiteral, Or } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEjF,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

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

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,13 @@
+import type { And } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"version":3,"file":"ExtendsAll.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ExtendsAll.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AAG3D,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

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

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

@@ -0,0 +1,11 @@
+import type { Not, ExtendsSome } from "inferred-types/dist/types/index";
+/**
+  * **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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAGxE;;;;;;;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

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

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

@@ -0,0 +1,11 @@
+import type { AfterFirst, First } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEzE;;;;;;;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

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

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

@@ -0,0 +1,10 @@
+import { AfterFirst, First, IsArray } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAE9E,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

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

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

@@ -0,0 +1,22 @@
+import type { IsUnion, UnionToTuple, IsStringLiteral, AllStringLiterals, AsArray, Or, And } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEzC,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

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

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

@@ -0,0 +1,9 @@
+import { Container } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"version":3,"file":"HasIndex.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACV,MAAM,iCAAiC,CAAC;AAEzC;;;;;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

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

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

@@ -0,0 +1,16 @@
+import type { ReplaceAll, IsWideType, TupleToUnion } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEzC,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

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

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

@@ -0,0 +1,14 @@
+import { Length, IsEqual, TypedFunction } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEnF;;;;;;;;;;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

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

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

@@ -0,0 +1,11 @@
+/**
+ * **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

@@ -0,0 +1 @@
+{"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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"HasRequiredProps.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasRequiredProps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAE7F;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,MAAM,IACd,CAAC,SAAS,UAAU,GACtB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,SAAS,EAAE,GACjD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACxC,KAAK,GACL,IAAI,GACN,KAAK,GACP,KAAK,CAAC"}

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

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

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

@@ -0,0 +1,13 @@
+import { And, AsTuple, Container, DoesExtend, HasSameValues, IsTuple, ObjectKey, RemoveIndexKeys, UnionToTuple } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAA;AAI7J,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

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

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

@@ -0,0 +1,19 @@
+import { And, Dictionary, If, IsNever, Or, Values } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAE3F,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

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

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

@@ -0,0 +1,10 @@
+import { AfterFirst, First, IsUnion } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAE9E,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

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

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

@@ -0,0 +1,10 @@
+import { AfterFirst, First, IsWideType } from "inferred-types/dist/types/index";
+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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEhF,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

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

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

@@ -0,0 +1,9 @@
+import { If, NumberLike, IsNegativeNumber, IsPositiveNumber } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEzC;;;;;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

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

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

@@ -0,0 +1,21 @@
+/**
+ * **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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1,20 @@
+import { UpperAlphaChar, If, HasCharacters } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"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,iCAAiC,CAAC;AAEnF;;;;;;;;;;;;;;;;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

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

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

@@ -0,0 +1,8 @@
+import { IsNever } from "inferred-types/dist/types/index";
+/**
+ * **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

@@ -0,0 +1 @@
+{"version":3,"file":"IsAny.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAny.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAE1D;;;;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

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