inferred-types 0.42.1 → 0.43.1

package/dist/types/boolean-logic/narrowing/AsSomething.d.ts

@@ -0,0 +1,20 @@
+import { IsUnion, Nothing, RemoveMarked, TupleToUnion, UnionToTuple } from "../../index";
+import { Constant } from "../../../constants/index";
+type Process<T extends readonly unknown[]> = TupleToUnion<RemoveMarked<{
+    [K in keyof T]: T[K] extends Nothing ? Constant<"Marked"> : T[K];
+}>>;
+/**
+ * **AsSomething**`<T>`
+ *
+ * Narrowing utility which takes a type `T` and _if it's a union_
+ * will narrow the union elements to no longer include `undefined`
+ * or `null`.
+ *
+ * - If `T` is a non-union type then:
+ *   - a `null` or `undefined` value will be mapped to `TNonUnion` (
+ * which defaults to `never`)
+ *   - all other values are just proxied through
+ */
+export type AsSomething<T, TNonUnion = never> = IsUnion<T> extends true ? Process<UnionToTuple<T>> : T extends Nothing ? TNonUnion : T;
+export {};
+//# sourceMappingURL=AsSomething.d.ts.map

package/dist/types/boolean-logic/narrowing/AsSomething.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsSomething.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/AsSomething.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,YAAY,EACb,oBAAwB;AACzB,OAAO,EAAE,QAAQ,EAAE,iCAA4B;AAE/C,KAAK,OAAO,CACV,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B,YAAY,CAChB,YAAY,CAAC;KACV,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,GAChC,QAAQ,CAAC,QAAQ,CAAC,GAClB,CAAC,CAAC,CAAC,CAAC;CACT,CAAC,CAAC,CAAC;AAEJ;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,EACD,SAAS,GAAG,KAAK,IACf,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACzB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GACxB,CAAC,SAAS,OAAO,GACf,SAAS,GACT,CAAC,CAAC"}

package/dist/types/boolean-logic/narrowing/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./AsIndexOf";
+export * from "./AsDoneFn";
+export * from "./AsSomething";
+export * from "./As";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/boolean-logic/narrowing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,MAAM,CAAC"}

package/dist/types/boolean-logic/narrowing/index.js

@@ -1 +1,4 @@
 export * from "./AsIndexOf.js";
+export * from "./AsDoneFn.js";
+export * from "./AsSomething.js";
+export * from "./As.js";

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

@@ -1,5 +1,5 @@
-import { AfterFirst, First, IfExtends } from "../../index";
-type AllAcc<TList extends readonly unknown[], TExtend> = [] extends TList ? true : IfExtends<First<TList>, TExtend, AllAcc<AfterFirst<TList>, TExtend>, false>;
+import { AfterFirst, First, If, Extends } from "../../index";
+type AllAcc<TList extends readonly unknown[], TExtend> = [] extends TList ? true : If<Extends<First<TList>, TExtend>, AllAcc<AfterFirst<TList>, TExtend>, false>;
 /**
   * **AllExtend**`<TList, TExtend>`
   *

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

@@ -1 +1 @@
-{"version":3,"file":"AllExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AllExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAG,SAAS,EAAE,oBAAwB;AAEhE,KAAK,MAAM,CACT,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,EAAE,SAAS,KAAK,GAChB,IAAI,GACJ,SAAS,CACP,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,EACrB,MAAM,CACJ,UAAU,CAAC,KAAK,CAAC,EACjB,OAAO,CACR,EACD,KAAK,CACN,CAAC;AAGN;;;;;;;IAOI;AACJ,MAAM,MAAM,SAAS,CACnB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,MAAM,CAAC,KAAK,EAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"AllExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AllExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAG,EAAE,EAAE,OAAO,EAAE,oBAAwB;AAElE,KAAK,MAAM,CACT,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,EAAE,SAAS,KAAK,GAChB,IAAI,GACJ,EAAE,CACA,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAC9B,MAAM,CACJ,UAAU,CAAC,KAAK,CAAC,EACjB,OAAO,CACR,EACD,KAAK,CACN,CAAC;AAGN;;;;;;;IAOI;AACJ,MAAM,MAAM,SAAS,CACnB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,MAAM,CAAC,KAAK,EAAC,OAAO,CAAC,CAAC"}

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

@@ -1,11 +1,11 @@
-import { AfterFirst, First, IfLiteral, Tuple } from "../../index";
-type Process<TRemaining extends Tuple> = [] extends TRemaining ? true : IfLiteral<First<TRemaining>, Process<AfterFirst<TRemaining>>, false>;
+import { And, IsStringLiteral, IsNumericLiteral, IsTuple, IsBooleanLiteral, IsObjectLiteral } from "../../index";
 /**
  * **AllLiteral**`<TTuple>`
  *
  * A boolean operator which tests whether all properties in
  * the tuple `TTuple` are _literal_ types.
  */
-export type AllLiteral<T extends Tuple> = Process<T>;
-export {};
+export type AllLiteral<T extends readonly unknown[]> = And<{
+    [K in keyof T]: IsStringLiteral<T[K]> extends true ? true : IsNumericLiteral<T[K]> extends true ? true : IsTuple<T[K]> extends true ? true : IsBooleanLiteral<T[K]> extends true ? true : IsObjectLiteral<T[K]> extends true ? true : false;
+}>;
 //# sourceMappingURL=AllLiteral.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AllLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AllLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,oBAAwB;AAEtE,KAAK,OAAO,CACV,UAAU,SAAS,KAAK,IACtB,EAAE,SAAS,UAAU,GACvB,IAAI,GACJ,SAAS,CACP,KAAK,CAAC,UAAU,CAAC,EACjB,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAC/B,KAAK,CACN,CAAC;AAEJ;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"AllLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AllLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,eAAe,EACf,gBAAgB,EAChB,OAAO,EACP,gBAAgB,EAChB,eAAe,EAChB,oBAAwB;AAEzB;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,GAAG,CAAC;KACxD,CAAC,IAAI,MAAM,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAChD,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACnC,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1B,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACnC,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAClC,IAAI,GACJ,KAAK;CACR,CAAC,CAAC"}

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

@@ -0,0 +1,12 @@
+import { And } from "../combinators/And";
+import { IsNumericLiteral } from "./IsNumericLiteral";
+/**
+ * **AllNumericLiterals**`<T>`
+ *
+ * Boolean operator which checks whether **all** of the
+ * passed in elements are _numeric literals_.
+ */
+export type AllNumericLiterals<T extends readonly unknown[]> = And<{
+    [K in keyof T]: IsNumericLiteral<T[K]>;
+}>;
+//# sourceMappingURL=AllNumericLiterals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AllNumericLiterals.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AllNumericLiterals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAC5B,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B,GAAG,CAAC;KACL,CAAC,IAAI,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACvC,CAAC,CAAA"}

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

@@ -0,0 +1,12 @@
+import { And } from "../combinators/And";
+import { IsStringLiteral } from "./IsStringLiteral";
+/**
+ * **AllStringLiterals**`<T>`
+ *
+ * Boolean operator which checks whether **all** of the
+ * passed in elements are _string literals_.
+ */
+export type AllStringLiterals<T extends readonly unknown[]> = And<{
+    [K in keyof T]: IsStringLiteral<T[K]>;
+}>;
+//# sourceMappingURL=AllStringLiterals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AllStringLiterals.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AllStringLiterals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAC3B,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B,GAAG,CAAC;KACL,CAAC,IAAI,MAAM,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACtC,CAAC,CAAA"}

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

@@ -0,0 +1,9 @@
+import { IsEqual, IsStringLiteral, IsTuple, Length } from "../../index";
+/**
+ * **AreSameLength**`<A,B>`
+ *
+ * Tests whether `A` and `B` are of equal length. Generics should
+ * be a `Tuple` or a string but not a combination of the two.
+ */
+export type AreSameLength<A extends string | readonly unknown[], B extends string | readonly unknown[]> = IsStringLiteral<A> extends true ? IsStringLiteral<B> extends true ? IsEqual<Length<A>, Length<B>> : IsTuple<B> extends true ? IsEqual<Length<A>, Length<B>> : boolean : IsTuple<A> extends true ? IsTuple<B> extends true ? IsEqual<Length<A>, Length<B>> : IsStringLiteral<B> extends true ? IsEqual<Length<A>, Length<B>> : boolean : boolean;
+//# sourceMappingURL=AreSameLength.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AreSameLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/AreSameLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,OAAO,EAAG,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,oBAAwB;AAI9E;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,MAAM,GAAG,SAAS,OAAO,EAAE,EACrC,CAAC,SAAS,MAAM,GAAG,SAAS,OAAO,EAAE,IAEvC,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GACzF,OAAO,GACP,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACnB,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACnB,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GAC7B,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GAC/D,OAAO,GACf,OAAO,CAAC"}

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

@@ -0,0 +1,18 @@
+import { Widen } from "../..";
+/**
+ * **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,OAAO,CAAC;AAE9B;;;;;;;;;;;;;;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/Contains.d.ts

@@ -1,10 +1,25 @@
-import { AfterFirst, First } from "../../index";
+import { AsString, IsWideType, Or } from "../../index";
+type ProcessStr<TContent extends string, TComparator extends string> = IsWideType<TComparator> extends true ? boolean : TContent extends `${string}${TComparator}${string}` ? true : false;
 /**
- * **Contains**`<TList,TContains>`
+ * 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[] ? ProcessTuple<TContent, TComparator> : TContent extends (string | number) ? ProcessStr<AsString<TContent>, AsString<TComparator>> : false;
+/**
+ * **Contains**`<TContent, TComparator>`
+ *
+ * Checks whether `TContent` _contains_ a value of `TComparator`:
  *
- * Checks whether a list -- `TList` -- contains a value of `TContains`.
+ * - 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<TList extends readonly unknown[], TContains> = [] extends TList ? false : First<TList> extends TContains ? true : [] extends AfterFirst<TList> ? false : Contains<AfterFirst<TList>, TContains>;
+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 +1 @@
-{"version":3,"file":"Contains.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Contains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,oBAAwB;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAClB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,SAAS,IACP,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,KAAK,CAAC,KAAK,CAAC,SAAS,SAAS,GAC9B,IAAI,GACJ,EAAE,SAAS,UAAU,CAAC,KAAK,CAAC,GAC5B,KAAK,GACL,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC"}
+{"version":3,"file":"Contains.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Contains.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,UAAU,EACV,EAAE,EACH,oBAAwB;AAEzB,KAAK,UAAU,CACb,QAAQ,SAAS,MAAM,EACvB,WAAW,SAAS,MAAM,IACxB,UAAU,CAAC,WAAW,CAAC,SAAS,IAAI,GACpC,OAAO,GACP,QAAQ,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,EAAE,GACjD,IAAI,GACJ,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;AAEH,KAAK,UAAU,CACb,QAAQ,EACR,WAAW,IACT,QAAQ,SAAS,SAAS,OAAO,EAAE,GACnC,YAAY,CAAC,QAAQ,EAAE,WAAW,CAAC,GACnC,QAAQ,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,GAChC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,GACrD,KAAK,CAAC;AAEZ;;;;;;;;;;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/DoesExtend.d.ts

@@ -1,7 +1,8 @@
+import { IsNever } from "../../index";
 /**
  * **DoesExtend**`<TValue, TExtends>`
  *
  * Boolean type utility which returns `true` if `TValue` _extends_ `TExtends`.
  */
-export type DoesExtend<TValue, TExtends> = TValue extends TExtends ? true : false;
+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 +1 @@
-{"version":3,"file":"DoesExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/DoesExtend.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,MAAM,MAAM,UAAU,CACpB,MAAM,EACN,QAAQ,IACN,MAAM,SAAS,QAAQ,GACvB,IAAI,GACJ,KAAK,CAAC"}
+{"version":3,"file":"DoesExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/DoesExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;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/EndsWith.d.ts

@@ -1,20 +1,21 @@
-import type { IfNumericLiteral, IsStringLiteral, IfString, ToString } from "../../index";
+import { AsString, IsStringLiteral, Or } from "../../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**<T,U>
+ * **EndsWith**<TValue, TComparator>
  *
- * A type utility which checks whether `T` _ends with_ the string literal `U`.
+ * A type utility which checks whether `TValue` _ends with_ the
+ * value of `TComparator`.
  *
- * If both `T` and `U` are string literals then the type system will resolve
- * to a literal `true` or `false` but if either is not a literal that it will
- * just resolve to `boolean` as the value can not be known at design time..
+ * - 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, TEndsWith extends string | number> = TEndsWith extends number ? EndsWith<TValue, ToString<TEndsWith>> : IfString<TValue, IsStringLiteral<TEndsWith> extends true ? IsStringLiteral<TValue> extends true ? TValue extends `${string}${TEndsWith}` ? true : false : boolean : boolean, TValue extends number ? IfNumericLiteral<TValue, EndsWith<ToString<TValue>, TEndsWith>, false> : false>;
-/**
- * **IfEndsWith**<TValue, TEndsWith, IF, ELSE, MAYBE>
- *
- * Type utility which converts type to `IF` type _if_ `TValue` _ends with_ `TEndsWith` but
- * otherwise converts type to `ELSE`. If there are wide types in the mix then the type will
- * result in the union of IF and ELSE.
- */
-export type IfEndsWith<TValue, TEndsWith, IF, ELSE> = TEndsWith extends string ? EndsWith<TValue, TEndsWith> extends true ? IF : EndsWith<TValue, TEndsWith> extends false ? ELSE : IF | ELSE : TEndsWith extends number ? number extends TEndsWith ? never : IfEndsWith<TValue, ToString<TEndsWith>, IF, ELSE> : never;
+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 +1 @@
-{"version":3,"file":"EndsWith.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/EndsWith.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ,EAAE,oBAAwB;AAE7F;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,CAClB,MAAM,EACN,SAAS,SAAS,MAAM,GAAG,MAAM,IAC/B,SAAS,SAAS,MAAM,GAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,GACrC,QAAQ,CACR,MAAM,EACN,eAAe,CAAC,SAAS,CAAC,SAAS,IAAI,GACnC,eAAe,CAAC,MAAM,CAAC,SAAS,IAAI,GAClC,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,EAAE,GACpC,IAAI,GACJ,KAAK,GACP,OAAO,GACT,OAAO,EACX,MAAM,SAAS,MAAM,GACjB,gBAAgB,CAChB,MAAM,EACN,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,EACrC,KAAK,CACN,GACC,KAAK,CACV,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CACpB,MAAM,EACN,SAAS,EACT,EAAE,EACF,IAAI,IACF,SAAS,SAAS,MAAM,GACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,IAAI,GACtC,EAAE,GACF,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,KAAK,GACzC,IAAI,GACJ,EAAE,GAAG,IAAI,GACX,SAAS,SAAS,MAAM,GACtB,MAAM,SAAS,SAAS,GACtB,KAAK,GACL,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,GACnD,KAAK,CAAC"}
+{"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,oBAAwB;AAEjE,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/Extends.d.ts

@@ -0,0 +1,9 @@
+import { DoesExtend } from "./DoesExtend";
+/**
+ * **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> = 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;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAC,CAAC,IAAI,UAAU,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC"}

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

@@ -1,17 +1,22 @@
-import type { AfterFirst, First, AsArray } from "../../index";
-type _HasChar<TStr extends string, TChars extends readonly string[]> = [] extends TChars ? false : TStr extends `${string}${First<TChars>}${string}` ? true : _HasChar<TStr, AfterFirst<TChars>>;
+import type { IsUnion, UnionToTuple, IsStringLiteral, AllStringLiterals, AsArray, Or, And } from "../../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>;
 /**
- * **HasCharacter**`<TStr,TChars>`
+ * **HasCharacters**`<TStr,TChars>`
  *
- * Boolean type utility which tests whether `TStr` has the
- * character `TChars` in it.
+ * Boolean type utility which tests whether `TStr` has _any_ of the
+ * characters in `TChars`.
  *
- * - If more than one character is provided in `TChars` then
- * the result will return **true** if _any_ of the characters
- * are present.
+ * - 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[]> = _HasChar<TStr, AsArray<TChars>>;
+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 +1 @@
-{"version":3,"file":"HasCharacters.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasCharacters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,oBAAwB;AAElE,KAAK,QAAQ,CACX,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,SAAS,MAAM,EAAE,IAC9B,EAAE,SAAS,MAAM,GACnB,KAAK,GACL,IAAI,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,GAC/C,IAAI,GACJ,QAAQ,CACN,IAAI,EACJ,UAAU,CAAC,MAAM,CAAC,CACnB,CAAC;AAEN;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,CACvB,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,IACvC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC"}
+{"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,oBAAwB;AAEzB,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/HasIndex.d.ts

@@ -0,0 +1,9 @@
+import { Container } from "../../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,oBAAwB;AAEzB;;;;;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/HasOtherCharacters.d.ts

@@ -0,0 +1,16 @@
+import type { ReplaceAll, IsWideType, TupleToUnion } from "../../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,oBAAwB;AAEzB,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/HasParameters.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction, Length, IsEqual } from "../../index";
+import { Length, IsEqual, TypedFunction } from "../../index";
 /**
  * **HasParameters**`<T>`
  *
@@ -10,5 +10,5 @@ import { AnyFunction, Length, IsEqual } from "../../index";
  * type P = HasParameters<typeof fn>;
  * ```
  */
-export type HasParameters<T> = T extends AnyFunction ? IsEqual<Length<Parameters<T>>, 0> extends true ? false : true : false;
+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 +1 @@
-{"version":3,"file":"HasParameters.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasParameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,MAAM,EAAG,OAAO,EAAE,oBAAwB;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAChD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC5C,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}
+{"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,oBAAwB;AAEnE;;;;;;;;;;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/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/HasRequiredProps.d.ts

@@ -0,0 +1,10 @@
+import { Dictionary } from "../../base-types/Dictionary";
+import { Keys, ObjectKey, RequiredProps } from "../..";
+/**
+ * **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,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEvD;;;;;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/HasSameKeys.d.ts

@@ -0,0 +1,13 @@
+import { And, AsTuple, Container, DoesExtend, HasSameValues, IsTuple, ObjectKey, RemoveIndexKeys, UnionToTuple } from "../../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,oBAAuB;AAI7I,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/HasSameValues.d.ts

@@ -1,5 +1,10 @@
-import { AfterFirst, First, Length, IfEqual, IfLength, Contains } from "../../index";
-type Compare<TList extends readonly unknown[], TComparator extends readonly unknown[]> = [] extends TComparator ? true : Contains<TList, First<TComparator>> extends true ? Compare<TList, AfterFirst<TComparator>> : false;
+import { And, Or } from "../../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>;
 /**
  * **HasSameValues**`<TList,TComparator>`
  *
@@ -7,7 +12,6 @@ type Compare<TList extends readonly unknown[], TComparator extends readonly unkn
  * `TList` and `TComparator` are the same (even if the order
  * is different).
  */
-export type HasSameValues<TList extends readonly unknown[], TComparator extends readonly unknown[]> = IfEqual<Length<TList>, Length<TComparator>, IfLength<TList, 0, // lengths are both 0
-true, Compare<TList, TComparator>>, false>;
+export type HasSameValues<TList extends readonly unknown[], TComparator extends readonly unknown[]> = TList["length"] extends TComparator["length"] ? Compare<TList, TComparator> : false;
 export {};
 //# sourceMappingURL=HasSameValues.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"HasSameValues.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasSameValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAG,OAAO,EAAE,QAAQ,EAAG,QAAQ,EAAE,oBAAwB;AAE3F,KAAK,OAAO,CACZ,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,WAAW,SAAS,SAAS,OAAO,EAAE,IAClC,EAAE,SAAS,WAAW,GACxB,IAAI,GACJ,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,SAAS,IAAI,GAC9C,OAAO,CACL,KAAK,EACL,UAAU,CAAC,WAAW,CAAC,CACxB,GACD,KAAK,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,CACvB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,WAAW,SAAS,SAAS,OAAO,EAAE,IACpC,OAAO,CACT,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,EAClC,QAAQ,CACN,KAAK,EAAE,CAAC,EAAE,qBAAqB;AAC/B,IAAI,EACJ,OAAO,CAAC,KAAK,EAAC,WAAW,CAAC,CAC3B,EACD,KAAK,CACN,CAAC"}
+{"version":3,"file":"HasSameValues.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasSameValues.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,oBAAwB;AAE1C,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;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,CACvB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,WAAW,SAAS,SAAS,OAAO,EAAE,IACpC,KAAK,CAAC,QAAQ,CAAC,SAAS,WAAW,CAAC,QAAQ,CAAC,GAC/C,OAAO,CACL,KAAK,EACL,WAAW,CACZ,GACD,KAAK,CAAC"}

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

@@ -1,5 +1,5 @@
-import { AfterFirst, First, IfUnion } from "../../index";
-type _HasUnion<TList extends readonly unknown[]> = [] extends TList ? false : IfUnion<First<TList>, true, _HasUnion<AfterFirst<TList>>>;
+import { AfterFirst, First, IsUnion } from "../../index";
+type _HasUnion<TList extends readonly unknown[]> = [] extends TList ? false : IsUnion<First<TList>> extends true ? true : _HasUnion<AfterFirst<TList>>;
 /**
  * **HasUnionType**`<TList>`
  *

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

@@ -1 +1 @@
-{"version":3,"file":"HasUnionType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/HasUnionType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,oBAAwB;AAE7D,KAAK,SAAS,CACZ,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAE9D;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC"}
+{"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,oBAAwB;AAE9D,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/HasWideValues.d.ts

@@ -1,5 +1,5 @@
-import { AfterFirst, First, IsLiteral } from "../../index";
-type Validate<T extends readonly unknown[]> = [] extends T ? false : IsLiteral<First<T>> extends true ? Validate<AfterFirst<T>> : true;
+import { AfterFirst, First, IsWideType } from "../../index";
+type Validate<T extends readonly unknown[]> = [] extends T ? false : IsWideType<First<T>> extends true ? true : Validate<AfterFirst<T>>;
 /**
  * **HasWideValues**`<T>`
  *

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

@@ -1 +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,SAAS,EAAE,oBAAwB;AAE/D,KAAK,QAAQ,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,EAAE,SAAS,CAAC,GACxD,KAAK,GACL,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9B,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACvB,IAAI,CAAC;AAET;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC"}
+{"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,oBAAwB;AAEhE,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/IsAllLowercase.d.ts

@@ -1,4 +1,4 @@
-import { UpperAlphaChar, IfHasCharacters } from "../../index";
+import { UpperAlphaChar, If, HasCharacters } from "../../index";
 /**
  * **IsAllLowercase**`<T>`
  *
@@ -16,5 +16,5 @@ import { UpperAlphaChar, IfHasCharacters } from "../../index";
  * type T = AllCaps<string>;
  * ```
  */
-export type IsAllLowercase<T extends string> = string extends T ? boolean : IfHasCharacters<T, UpperAlphaChar, true, false>;
+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 +1 @@
-{"version":3,"file":"IsAllLowercase.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAllLowercase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,oBAAwB;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,SAAS,CAAC,GAC3D,OAAO,GACP,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC"}
+{"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,oBAAwB;AAEnE;;;;;;;;;;;;;;;;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/IsAny.d.ts

@@ -1,8 +1,8 @@
-import { IfNever } from "../../index";
+import { IsNever } from "../../index";
 /**
  * **IsAny**`<T>`
  *
  * Tests whether a given `T` is of the **any** type.
  */
-export type IsAny<T> = IfNever<T, false, 1 extends T & 0 ? true : false>;
+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 +1 @@
-{"version":3,"file":"IsAny.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAny.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC"}
+{"version":3,"file":"IsAny.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsAny.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;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/IsBooleanLiteral.d.ts

@@ -1,9 +1,9 @@
-import type { IfBoolean, IfEqual } from "../../index";
+import type { IsFalse, IsNever, IsTrue } from "../../index";
 /**
  * **IsBooleanLiteral**`<T>`
  *
  * Boolean type utility which detects whether `T`
  * is a boolean literal (aka, is `true` or `false`)
  */
-export type IsBooleanLiteral<T> = IfBoolean<T, IfEqual<T, boolean, false, true>, false>;
+export type IsBooleanLiteral<T> = [IsNever<T>] extends [true] ? false : [IsTrue<T>] extends [true] ? true : [IsFalse<T>] extends [true] ? true : false;
 //# sourceMappingURL=IsBooleanLiteral.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsBooleanLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsBooleanLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAwB;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC"}
+{"version":3,"file":"IsBooleanLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsBooleanLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAI,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,oBAAwB;AAIlE;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,IACC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3B,KAAK,GACL,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACxB,IAAI,GACJ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3B,IAAI,GACJ,KAAK,CAAC"}

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

@@ -1,11 +1,9 @@
-import type { AnyObject, IfNever } from "../../index";
+import type { IsNever, Dictionary } from "../../index";
 /**
  * **IsContainer**`<T>`
  *
  * Boolean operator which detects whether `T` is a "container" where a
  * container is any object or array.
  */
-export type IsContainer<T> = IfNever<T, false, [
-    T
-] extends [AnyObject] ? true : [T] extends [any[]] ? true : false>;
+export type IsContainer<T> = IsNever<T> extends true ? false : [T] extends [Dictionary] ? true : [T] extends [readonly any[]] ? true : false;
 //# sourceMappingURL=IsContainer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsContainer.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsContainer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAwB;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAC7C;IAAC,CAAC;CAAC,SAAS,CAAC,SAAS,CAAC,GACnB,IAAI,GACJ,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GACjB,IAAI,GACJ,KAAK,CACV,CAAC"}
+{"version":3,"file":"IsContainer.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsContainer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAG,OAAO,EAAE,UAAU,EAAE,oBAAwB;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAClD,KAAK,GACL,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GACtB,IAAI,GACJ,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC,GAC1B,IAAI,GACJ,KAAK,CAAC"}