inferred-types 0.42.1 → 0.43.0

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

@@ -1,4 +1,4 @@
-import { IfNever, IfStringLiteral, SingularNoun } from "../../index";
+import { If, IfNever, IsStringLiteral, SingularNoun } from "../../index";
 /**
  * **IsSingularNoun**`<T>`
  *
@@ -9,5 +9,5 @@ import { IfNever, IfStringLiteral, SingularNoun } from "../../index";
  * - `boolean` - if `T` is a wide string type
  * - `false` - all other conditions
  */
-export type IsSingularNoun<T> = T extends string ? IfStringLiteral<T, IfNever<SingularNoun<T>, false, true>, boolean> : false;
+export type IsSingularNoun<T> = T extends string ? If<IsStringLiteral<T>, IfNever<SingularNoun<T>, false, true>, boolean> : false;
 //# sourceMappingURL=IsSingularNoun.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsSingularNoun.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsSingularNoun.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,oBAAwB;AAGzE;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC5C,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,GAClE,KAAK,CAAC"}
+{"version":3,"file":"IsSingularNoun.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsSingularNoun.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,oBAAwB;AAG7E;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC5C,EAAE,CACA,eAAe,CAAC,CAAC,CAAC,EAClB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EACrC,OAAO,CACR,GACD,KAAK,CAAC"}

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

@@ -1,8 +1,9 @@
+import { IsUnion } from "./IsUnion";
 /**
  * **IsString**
  *
  * Type utility which returns true/false based on whether `T` is a
  * string (wide or narrow).
  */
-export type IsString<T> = T extends string ? true : false;
+export type IsString<T> = IsUnion<T> extends true ? [string] extends [T] ? boolean : false : [T] extends [string] ? true : false;
 //# sourceMappingURL=IsString.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsString.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsString.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"IsString.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/C,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAClB,OAAO,GACP,KAAK,GACP,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

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

@@ -1,11 +1,9 @@
-import { IfNever } from "../../index";
+import { IsEqual, IsNever } from "../../index";
 /**
  * **IsStringLiteral**`<T>`
  *
  * Boolean type utility which detects whether `T` is
  * a string literal.
  */
-export type IsStringLiteral<T> = IfNever<T, never, [
-    T
-] extends [string] ? string extends T ? false : true : false>;
+export type IsStringLiteral<T> = IsNever<T> extends true ? false : T extends string ? IsEqual<T, string> extends true ? false : true : false;
 //# sourceMappingURL=IsStringLiteral.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsStringLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsStringLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EACjD;IAAC,CAAC;CAAC,SAAS,CAAC,MAAM,CAAC,GAChB,MAAM,SAAS,CAAC,GACd,KAAK,GACL,IAAI,GACN,KAAK,CACR,CAAC"}
+{"version":3,"file":"IsStringLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsStringLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACpD,KAAK,GACL,CAAC,SAAS,MAAM,GACd,OAAO,CAAC,CAAC,EAAC,MAAM,CAAC,SAAS,IAAI,GAC5B,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}

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

@@ -1,6 +1,7 @@
 import { IsEqual, IsNever } from "../../index";
+type Process<T, TNever> = [IsNever<T>] extends [true] ? TNever : [IsEqual<T, true>] extends [true] ? true : false;
 /**
- * **IsTrue**`<T>`
+ * **IsTrue**`<T,[TNever]>`
  *
  * Type utility which checks for the narrow type of `true`
  * ```ts
@@ -12,5 +13,6 @@ import { IsEqual, IsNever } from "../../index";
  * type F2 = IsTrue<"foobar">;
  * ```
  */
-export type IsTrue<T> = IsNever<T> extends true ? never : IsEqual<T, true> extends true ? true : false;
+export type IsTrue<T, TNever = never> = Process<T, TNever>;
+export {};
 //# sourceMappingURL=IsTrue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,OAAO,EAAE,oBAAwB;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7C,KAAK,GACL,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,KAAK,CAAC"}
+{"version":3,"file":"IsTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,OAAO,EAAE,oBAAwB;AAEpD,KAAK,OAAO,CAAC,CAAC,EACd,MAAM,IACF,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,MAAM,GACN,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,IAAI,GACJ,KAAK,CAAC;AAER;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,MAAM,GAAG,KAAK,IACZ,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC"}

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

@@ -1,11 +1,13 @@
-import { IfLiteral, IfSomeEqual } from "../../index";
+import { If, IsNumericLiteral, IsStringLiteral, IsFalse, IsTrue, SomeEqual } from "../../index";
 /**
- * **Truthy**`<T>`
+ * **IsTruthy**`<T>`
  *
  * A type utility which evaluates `T` for _[truthiness](https://frontend.turing.edu/lessons/module-1/js-truthy-falsy-expressions.html)_ and returns `true` or `false`
  * where the state can be detected at design time; otherwise returns `boolean`.
  *
  * **See Also:** `IfTruthy`, `IfSomeTruthy`, `IfAllTruthy`, and `TruthyReturns`
  */
-export type IsTruthy<T> = T extends string ? T extends "" ? false : IfLiteral<T, true, boolean> : T extends number ? IfLiteral<T, IfSomeEqual<T, [0, -0], false, true>, boolean> : T extends boolean ? T extends false ? false : IfLiteral<T, true, boolean> : IfSomeEqual<T, [null, undefined, typeof NaN], false, boolean>;
+export type IsTruthy<T> = [
+    T
+] extends [string] ? T extends "" ? false : If<IsStringLiteral<T>, true, boolean> : [T] extends [number] ? If<IsNumericLiteral<T>, If<SomeEqual<[0, -0], T>, false, true>, boolean> : [T] extends [boolean] ? If<IsFalse<T>, false, If<IsTrue<T>, true, boolean>> : If<SomeEqual<[null, undefined, typeof NaN], T>, false, boolean>;
 //# sourceMappingURL=IsTruthy.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsTruthy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTruthy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,oBAAwB;AAGzD;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IACpB,CAAC,SAAS,MAAM,GACZ,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,GACpD,CAAC,SAAS,MAAM,GACd,SAAS,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,GAC3D,CAAC,SAAS,OAAO,GACf,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,GACrD,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC"}
+{"version":3,"file":"IsTruthy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTruthy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,EAAE,EACF,gBAAgB,EAChB,eAAe,EACf,OAAO,EACP,MAAM,EACN,SAAS,EACV,oBAAwB;AAGzB;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IACpB;IAAC,CAAC;CAAC,SAAS,CAAC,MAAM,CAAC,GAChB,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,GAC9D,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAClB,EAAE,CACA,gBAAgB,CAAC,CAAC,CAAC,EACnB,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,EAAG,KAAK,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,GAClD,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GACnB,EAAE,CACA,OAAO,CAAC,CAAC,CAAC,EACV,KAAK,EACL,EAAE,CACA,MAAM,CAAC,CAAC,CAAC,EACT,IAAI,EACJ,OAAO,CACR,CACF,GACH,EAAE,CACA,SAAS,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC,EAAC,CAAC,CAAC,EAC1C,KAAK,EACL,OAAO,CACR,CAAC"}

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

@@ -1,4 +1,5 @@
-import { IfNever } from "../branching/IfNever";
+import { IsNever } from "./IsNever";
+type Process<T> = [IsNever<T>] extends [true] ? false : T extends readonly unknown[] ? number extends T["length"] ? false : true : false;
 /**
  * **IfTuple**`<T>`
  *
@@ -11,5 +12,6 @@ import { IfNever } from "../branching/IfNever";
  * - types such as `string[]`, etc. are _not_ tuples as they
  * do not discretely specify a length of elements
  */
-export type IsTuple<T> = IfNever<T, never, T extends readonly unknown[] ? number extends T["length"] ? false : true : false>;
+export type IsTuple<T> = Process<T> extends boolean ? Process<T> : never;
+export {};
 //# sourceMappingURL=IsTuple.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsTuple.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAG9C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,OAAO,CAC9B,CAAC,EACD,KAAK,EACL,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACxB,KAAK,GACL,IAAI,GACN,KAAK,CACR,CAAA"}
+{"version":3,"file":"IsTuple.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,KAAK,GACL,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GACxB,KAAK,GACL,IAAI,GACN,KAAK,CAAC;AAGV;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,GACjD,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAC"}

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

@@ -1,9 +1,9 @@
-import { UnionToTuple, IfLength, IfNever } from "../../index";
+import { UnionToTuple, IsNever, IsEqual } from "../../index";
 /**
  * **IsUnion**`<T>`
  *
  * Type utility which returns a boolean flag indicating whether the
  * given `T` is typed as a _union_ type.
  */
-export type IsUnion<T> = IfNever<UnionToTuple<T>, false, IfLength<UnionToTuple<T>, 1, false, IfLength<UnionToTuple<T>, 0, false, true>>>;
+export type IsUnion<T> = [IsNever<UnionToTuple<T>>] extends [true] ? false : IsEqual<T, boolean> extends true ? false : UnionToTuple<T>["length"] extends 1 ? false : true;
 //# sourceMappingURL=IsUnion.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAG,QAAQ,EAAE,OAAO,EAAE,oBAAwB;AAEnE;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,OAAO,CAC9B,YAAY,CAAC,CAAC,CAAC,EACf,KAAK,EACL,QAAQ,CACN,YAAY,CAAC,CAAC,CAAC,EACf,CAAC,EACD,KAAK,EACL,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAC1C,CACF,CAAC"}
+{"version":3,"file":"IsUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAG,OAAO,EAAG,OAAO,EAAE,oBAAwB;AAGnE;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAChE,KAAK,GACL,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAChC,KAAK,GACL,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACjC,KAAK,GACL,IAAI,CAAC"}

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

@@ -1,20 +1,15 @@
-import { Container, DotPathFor, IfNever, IfExtends, IfLiteral, IfStringLiteral } from "../../index";
+import { Contains, DotPathFor, IsContainer, IsDotPath, IsEqual, IsObjectLiteral, IsTuple } from "../../index";
 /**
- * **IsValidDotPath**`<TContainer, TKey>`
+ * **IsValidDotPath**`<TContainer,TDotPath>`
  *
- * Boolean operator which detects whether a given key of `TKey` should be considered a
- * valid "dot path" for the container `TContainer`. Results based on `TKey` are:
- *
- * - `false`
- *    - any non-string type or any string literal in which `DotPath<T>` resolves
- * to false (including _never_ value).
- * - `boolean`
- *    - when a `TContainer` maps to a wide container type then we have to return boolean
- * as the validity of the key can not be determined at design time
- *    - the same applies to `TKey` being a wide string type
- * - `true` - a string literal value where `DotPath<T>` does not resolve to _never_.
- *
- * Note: this utility not only validates that `TKey` is a valid key in principle but that it is a valid key for `TContainer`; if you prefer a simpler check then use `IsDotPath<T>` instead.
+ * - if `TContainer` is a literal value than it will validate against
+ * the _actual_ dot paths which are valid for the container.
+ * - if `TContainer` is a wide container type then it will generically validate
+ * whether the dot path _could_ be a valid path.
+ * - if `TContainer` isn't a container at all then the only valid dot path is
+ * an empty string
+ * - a DotPath of either "" or null is _always_ valid because these are _identity_
+ * paths that simply return the container.
  */
-export type IsValidDotPath<TContainer, TKey> = IfNever<TKey, false, IfNever<TContainer, false, TContainer extends Container ? TKey extends string ? IfLiteral<TContainer, IfStringLiteral<TKey, IfExtends<TKey, DotPathFor<TContainer>, true, false>, boolean>, boolean> : false : false>>;
+export type IsValidDotPath<TContainer, TDotPath extends string | null> = IsEqual<TDotPath, null> extends true ? true : IsObjectLiteral<TContainer> extends true ? IsTuple<TContainer> extends true ? Contains<DotPathFor<TContainer>, TDotPath> : IsContainer<TContainer> extends true ? IsDotPath<TDotPath> : IsEqual<TDotPath, ""> extends true ? true : false : IsContainer<TContainer> extends true ? IsDotPath<TDotPath> : IsEqual<TDotPath, ""> extends true ? true : false;
 //# sourceMappingURL=IsValidDotPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsValidDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsValidDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAwB;AAExG;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,CAAC,UAAU,EAAC,IAAI,IAC1C,OAAO,CACL,IAAI,EACJ,KAAK,EACL,OAAO,CACL,UAAU,EACV,KAAK,EACL,UAAU,SAAS,SAAS,GACxB,IAAI,SAAS,MAAM,GACjB,SAAS,CACP,UAAU,EACV,eAAe,CACb,IAAI,EACJ,SAAS,CACP,IAAI,EAAE,UAAU,CAAC,UAAU,CAAC,EAC5B,IAAI,EACJ,KAAK,CACJ,EACD,OAAO,CACR,EACD,OAAO,CACR,GACD,KAAK,GACT,KAAK,CACV,CACF,CAAC"}
+{"version":3,"file":"IsValidDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsValidDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,UAAU,EACV,WAAW,EACX,SAAS,EACT,OAAO,EACP,eAAe,EACf,OAAO,EACR,oBAAwB;AAGzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,cAAc,CACxB,UAAU,EACV,QAAQ,SAAS,MAAM,GAAG,IAAI,IAC5B,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,IAAI,GACtC,IAAI,GACJ,eAAe,CAAC,UAAU,CAAC,SAAS,IAAI,GACxC,OAAO,CAAC,UAAU,CAAC,SAAS,IAAI,GAC9B,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,GAC1C,WAAW,CAAC,UAAU,CAAC,SAAS,IAAI,GAClC,SAAS,CAAC,QAAQ,CAAC,GACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,KAAK,GACT,WAAW,CAAC,UAAU,CAAC,SAAS,IAAI,GACpC,SAAS,CAAC,QAAQ,CAAC,GACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,KAAK,CAAC"}

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

@@ -0,0 +1,11 @@
+import { Abs, AsNumber, Container, ExplicitlyEmptyObject, IsEqual, IsNegativeNumber, IsStringLiteral, IsObjectLiteral, IsTuple, Dictionary, Tuple, NumericKeys, TupleToUnion } from "../../index";
+/**
+ * **IsValidIndex**`<TContainer,TKey>`
+ *
+ * Provides a boolean check on whether `TKey` is a valid key for `TContainer`.
+ *
+ * - valid responses are `true` or `false` if literal types found; otherwise `boolean`
+ * - negative indexes are allowed when `TContainer` is a tuple
+ */
+export type IsValidIndex<TContainer extends Container, TKey extends PropertyKey> = TContainer extends Tuple ? IsTuple<TContainer> extends true ? TKey extends number ? IsNegativeNumber<AsNumber<TKey>> extends true ? Abs<AsNumber<TKey>> extends number ? [Abs<AsNumber<TKey>>] extends [TupleToUnion<NumericKeys<TContainer>>] ? true : false : never : [TKey] extends [TupleToUnion<NumericKeys<TContainer>>] ? true : false : false : boolean : TContainer extends Dictionary ? IsEqual<TContainer, ExplicitlyEmptyObject> extends true ? false : [IsObjectLiteral<TContainer>] extends [true] ? [IsStringLiteral<TKey>] extends [true] ? [TKey] extends [keyof TContainer] ? true : false : [TKey] extends [symbol] ? [TKey] extends [keyof TContainer] ? true : false : false : boolean : false;
+//# sourceMappingURL=IsValidIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsValidIndex.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsValidIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,SAAS,EACT,qBAAqB,EACrB,OAAO,EACP,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,KAAK,EACL,WAAW,EACX,YAAY,EACb,oBAAwB;AAEzB;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CACtB,UAAU,SAAS,SAAS,EAC5B,IAAI,SAAS,WAAW,IACtB,UAAU,SAAS,KAAK,GAC1B,OAAO,CAAC,UAAU,CAAC,SAAS,IAAI,GAC9B,IAAI,SAAS,MAAM,GACjB,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,GAC3C,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,GAChC,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,GACnE,IAAI,GACJ,KAAK,GACP,KAAK,GACP,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,GACpD,IAAI,GACJ,KAAK,GACT,KAAK,GACP,OAAO,GAET,UAAU,SAAS,UAAU,GAC3B,OAAO,CAAC,UAAU,EAAE,qBAAqB,CAAC,SAAS,IAAI,GACnD,KAAK,GACL,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC5C,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACpC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,GAC/B,IAAI,GACJ,KAAK,GACP,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GACrB,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,GAC/B,IAAI,GACJ,KAAK,GACP,KAAK,GACT,OAAO,GACb,KAAK,CAAC"}

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

@@ -0,0 +1,14 @@
+import { If, IsEqual, ObjectKey, RemoveIndexKeys, Retain, UnionToTuple } from "../../index";
+type _Keys<T extends object> = UnionToTuple<keyof RemoveIndexKeys<T>> extends readonly ObjectKey[] ? UnionToTuple<keyof RemoveIndexKeys<T>> : never;
+type _Len<T extends object> = _Keys<T> extends ObjectKey[] ? _Keys<T>["length"] : 0;
+type _Validate<T extends object> = "value" extends keyof T ? true : false;
+/**
+ * **IsVueRef**`<T>`
+ *
+ * Boolean type utility that detects whether the type passed in
+ * is a VueJS `Ref<...>` type or this library's `VueRef<...>`
+ * (which serves as a lightweight proxy type for Vue's `Ref`).
+ */
+export type IsVueRef<T> = T extends object ? If<IsEqual<_Len<T>, 0>, false, Retain<_Keys<T>, string>["length"] extends 1 ? _Validate<T> : false> : false;
+export {};
+//# sourceMappingURL=IsVueRef.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsVueRef.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsVueRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,EAAE,EAAG,OAAO,EAAG,SAAS,EAAG,eAAe,EAAI,MAAM,EAAG,YAAY,EAAE,oBAAwB;AAIvG,KAAK,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,SACrE,SAAS,SAAS,EAAE,GAChB,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,GACtC,KAAK,CAAC;AAEV,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,SAAS,SAAS,EAAE,GACtD,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAClB,CAAC,CAAC;AAEN,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,IAAI,OAAO,SAAS,MAAM,CAAC,GACxD,IAAI,GACJ,KAAK,CAAA;AAGP;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GACxC,EAAE,CACA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EACnB,KAAK,EACL,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACxC,SAAS,CAAC,CAAC,CAAC,GACZ,KAAK,CACR,GACH,KAAK,CAAC"}

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

@@ -1,8 +1,51 @@
-import { IfLiteral, IfLiteralKind, Type } from "../../index";
-type WideLiterals = string | number | boolean | Record<string, any>;
+import { Container, ErrorCondition, IsEqual, IsNever, IsVueRef, IsWideUnion, ObjectKey, ProxyError, RemoveIndexKeys, Scalar, Throw, UnionToTuple } from "../../index";
 /**
- * **IsWideType**`<T>`
+ * **IsWideScalar**`<T>`
+ *
+ * Boolean operator which validates whether or not `T`
+ * is considered a "wide type" which extends `Scalar`
  */
-export type IsWideType<T> = T extends WideLiterals ? IfLiteral<T, false, true> : T extends Type<any> ? T extends Type<infer Kind> ? IfLiteralKind<Kind, false, true> : never : never;
+export type IsWideScalar<T> = [T] extends [Scalar] ? [
+    IsEqual<T, string, true, false>,
+    IsEqual<T, number, true, false>,
+    IsEqual<T, boolean, true, false>,
+    IsEqual<T, null, true, false>,
+    IsEqual<T, symbol, true, false>
+] extends [
+    false,
+    false,
+    false,
+    false,
+    false
+] ? false : true : false;
+type _Keys<T extends object> = UnionToTuple<keyof RemoveIndexKeys<T>>;
+type GetKeys<T extends object> = IsVueRef<T> extends true ? ["value"] : _Keys<T> extends [symbol] ? ObjectKey[] : _Keys<T> extends [] ? UnionToTuple<keyof T> extends [ObjectKey] ? (keyof T)[] : ObjectKey[] : _Keys<T>;
+/**
+ * **IsWideContainer**`<T>`
+ *
+ * Boolean operator which tests wether `T` is a `Container` and
+ * also a `wide type` (aka, not a literal).
+ */
+export type IsWideContainer<T> = T extends Container ? T extends readonly unknown[] ? "length" extends keyof T ? IsEqual<T["length"], number> extends true ? true : false : false : T extends object ? "length" extends keyof GetKeys<T> ? IsEqual<GetKeys<T>["length"], number> extends true ? true : false : false : false : false;
+type InvalidNever = Throw<"invalid-never", `The value of T when calling IsWideType<T> was "never" which makes the comparison invalid! If you want prefer to instead allow this condition then set the TNever generic to true or false depending on your preferred outcome`, "IsWideType", {
+    library: "inferred-types";
+}>;
+/**
+ * **IsWideType**`<T, [TNever]>`
+ *
+ * Identifies types which are "wide" (and have a narrow variant):
+ *
+ * - string, number, and boolean types
+ * - `string[]`, `number[]` array types
+ * - wide union types like `string | number`
+ *
+ * **Note:**
+ * - types such as `null` and `undefined` **are** considered wide.
+ * - If the `T` passed in is _never_ the result of this operation is
+ * ErrorCondition<"invalid-never"> but this can be made into whatever
+ * you like by setting the `TNever` generic.
+ * - If an ErrorCondition is in `T` then it will be bubbled up
+ */
+export type IsWideType<T, TNever = InvalidNever> = [IsNever<T>] extends [true] ? TNever : [T] extends [ErrorCondition] ? ProxyError<T, "IsWideType"> : IsWideScalar<T> extends true ? true : IsWideContainer<T> extends true ? true : IsWideUnion<T> extends true ? true : false;
 export {};
 //# sourceMappingURL=IsWideType.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsWideType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsWideType.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,oBAAwB;AAGjE,KAAK,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAC,GAAG,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,YAAY,GAC9C,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,GACzB,CAAC,SAAS,IAAI,CAAC,GAAG,CAAC,GACjB,CAAC,SAAS,IAAI,CAAC,MAAM,IAAI,CAAC,GACxB,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,GAChC,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"IsWideType.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsWideType.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,cAAc,EACd,OAAO,EACP,OAAO,EACP,QAAQ,EACR,WAAW,EACX,SAAS,EACT,UAAU,EACV,eAAe,EACf,MAAM,EACN,KAAK,EACL,YAAY,EACb,oBAAwB;AAEzB;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAC9C;IACE,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC,KAAK,CAAC;IAC9B,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC,KAAK,CAAC;IAC9B,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC,KAAK,CAAC;IAC/B,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAC,KAAK,CAAC;IAC5B,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAC,KAAK,CAAC;CAC/B,SAAS;IACR,KAAK;IAAE,KAAK;IAAE,KAAK;IAAE,KAAK;IAAE,KAAK;CAClC,GACG,KAAK,GACL,IAAI,GACV,KAAK,CAAC;AAER,KAAK,KAAK,CACR,CAAC,SAAS,MAAM,IACZ,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7C,KAAK,OAAO,CACV,CAAC,SAAS,MAAM,IACd,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1B,CAAC,OAAO,CAAC,GACT,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACvB,SAAS,EAAE,GACX,KAAK,CAAC,CAAC,CAAC,SAAS,EAAE,GACjB,YAAY,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,GACvC,CAAC,MAAM,CAAC,CAAC,EAAE,GACX,SAAS,EAAE,GACb,KAAK,CAAC,CAAC,CAAC,CAAC;AAGf;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAClD,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,QAAQ,SAAS,MAAM,CAAC,GACtB,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,IAAI,GACvC,IAAI,GACJ,KAAK,GACP,KAAK,GACP,CAAC,SAAS,MAAM,GACd,QAAQ,SAAS,MAAM,OAAO,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,IAAI,GAChD,IAAI,GACJ,KAAK,GACP,KAAK,GACP,KAAK,GACT,KAAK,CAAC;AAIR,KAAK,YAAY,GAAG,KAAK,CACvB,eAAe,EACf,+NAA+N,EAC/N,YAAY,EACZ;IAAE,OAAO,EAAE,gBAAgB,CAAA;CAAC,CAC7B,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,EACD,MAAM,GAAG,YAAY,IACnB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,MAAM,GACN,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,GAC5B,UAAU,CAAC,CAAC,EAAC,YAAY,CAAC,GAC3B,YAAY,CAAC,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/B,IAAI,GACJ,WAAW,CAAC,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,KAAK,CAAC"}

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

@@ -0,0 +1,15 @@
+import { IsUnion, IsWideType, UnionToTuple } from "../../index";
+type Process<T extends readonly unknown[]> = {
+    [K in keyof T]: IsWideType<T[K]>;
+};
+/**
+ * **IsWideUnion**`<T>`
+ *
+ * Boolean utility which checks whether `T` is both a _union type_
+ * and that it's elements are all considered _wide types_.
+ *
+ * **Related:** `IsNonLiteralUnion`
+ */
+export type IsWideUnion<T> = [IsUnion<T>] extends [true] ? [Process<UnionToTuple<T>>] extends [readonly true[]] ? true : false : false;
+export {};
+//# sourceMappingURL=IsWideUnion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsWideUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsWideUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,UAAU,EACV,YAAY,EACb,oBAAwB;AAEzB,KAAK,OAAO,CACV,CAAC,SAAS,SAAS,OAAO,EAAE,IAC1B;KACD,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACtD,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC,GAClD,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

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

@@ -1,8 +1,8 @@
-import { IfNotEqual, Length } from "../../index";
+import { If, IsNotEqual, Length } from "../../index";
 /**
  * **NotLength**`<T>`
  *
  * Boolean operator which detects whether `T` is _not_ a certain length.
  */
-export type NotLength<T extends readonly unknown[], U extends number> = IfNotEqual<Length<T>, U, true, false>;
+export type NotLength<T extends readonly unknown[], U extends number> = If<IsNotEqual<Length<T>, U>, true, false>;
 //# sourceMappingURL=NotLength.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"NotLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/NotLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,oBAAwB;AAErD;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,MAAM,IAAI,UAAU,CAChF,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EACZ,IAAI,EACJ,KAAK,CACN,CAAC"}
+{"version":3,"file":"NotLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/NotLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,oBAAwB;AAEzD;;;;GAIG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAAE,CAAC,SAAS,MAAM,IAAI,EAAE,CACxE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EACxB,IAAI,EACJ,KAAK,CACN,CAAC"}

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

@@ -1,9 +1,9 @@
-import { AnyFunction } from "../../index";
+import { TypedFunction } from "../../index";
 /**
  * **Returns**`<TFn,TExpected>`
  *
  * Boolean type utility which detects whether `TFn` is a function
  * and _extends_ `TExpected` in it's return type.
  */
-export type Returns<TFn, TExpected> = TFn extends AnyFunction ? ReturnType<TFn> extends TExpected ? true : false : false;
+export type Returns<TFn, TExpected> = TFn extends TypedFunction ? ReturnType<TFn> extends TExpected ? true : false : false;
 //# sourceMappingURL=Returns.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Returns.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Returns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAE9C;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,GAAG,EACH,SAAS,IACP,GAAG,SAAS,WAAW,GACvB,UAAU,CAAC,GAAG,CAAC,SAAS,SAAS,GAC/B,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"Returns.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Returns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,aAAa,EAAE,oBAAwB;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,GAAG,EACH,SAAS,IACP,GAAG,SAAS,aAAa,GACzB,UAAU,CAAC,GAAG,CAAC,SAAS,SAAS,GAC/B,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { AnyFunction, IfBoolean } from "../../index";
+import { IsBoolean, TypedFunction } from "../../index";
 /**
  * **ReturnsBoolean**`<T>`
  *
@@ -7,5 +7,5 @@ import { AnyFunction, IfBoolean } from "../../index";
  *
  * Note: any non-functions passed in as `T` are always a **false** value
  */
-export type ReturnsBoolean<T> = T extends AnyFunction ? IfBoolean<ReturnType<T>, true, false> : false;
+export type ReturnsBoolean<T> = T extends TypedFunction ? IsBoolean<ReturnType<T>> : false;
 //# sourceMappingURL=ReturnsBoolean.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ReturnsBoolean.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,SAAS,EAAE,oBAAwB;AAE1D;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GACjD,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,GACrC,KAAK,CAAC"}
+{"version":3,"file":"ReturnsBoolean.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAI,SAAS,EAAE,aAAa,EAAE,oBAAwB;AAE7D;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GACnD,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACxB,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { AnyFunction, IsEqual } from "../../index";
+import { IsEqual, TypedFunction } from "../../index";
 /**
  * **ReturnsTrue**`<T>`
  *
@@ -7,5 +7,5 @@ import { AnyFunction, IsEqual } from "../../index";
  *
  * Note: any non-functions passed in as `T` are removed from the result set
  */
-export type ReturnsFalse<T> = T extends AnyFunction ? ReturnType<T> extends false ? true : IsEqual<ReturnType<T>, boolean> extends true ? boolean : false : false;
+export type ReturnsFalse<T> = T extends TypedFunction ? ReturnType<T> extends false ? true : IsEqual<ReturnType<T>, boolean> extends true ? boolean : false : false;
 //# sourceMappingURL=ReturnsFalse.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ReturnsFalse.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,OAAO,EAAE,oBAAwB;AAExD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAC/C,UAAU,CAAC,CAAC,CAAC,SAAS,KAAK,GACzB,IAAI,GACJ,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,OAAO,GAAG,KAAK,GAChE,KAAK,CAAC"}
+{"version":3,"file":"ReturnsFalse.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,oBAAwB;AAEzD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GACjD,UAAU,CAAC,CAAC,CAAC,SAAS,KAAK,GACzB,IAAI,GACJ,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,OAAO,GAAG,KAAK,GAChE,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { AnyFunction } from "../../index";
+import { TypedFunction } from "../../index";
 /**
  * **ReturnsTrue**`<T>`
  *
@@ -8,5 +8,5 @@ import { AnyFunction } from "../../index";
  * Note: any non-functions passed in as `T` are always a **false** value
  * and so is a `boolean` value
  */
-export type ReturnsTrue<T> = T extends AnyFunction ? ReturnType<T> extends true ? true : false : false;
+export type ReturnsTrue<T> = T extends TypedFunction ? ReturnType<T> extends true ? true : false : false;
 //# sourceMappingURL=ReturnsTrue.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ReturnsTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAG9C;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAC9C,UAAU,CAAC,CAAC,CAAC,SAAS,IAAI,GACxB,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"ReturnsTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/ReturnsTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,aAAa,EAAE,oBAAwB;AAGjD;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,aAAa,GAChD,UAAU,CAAC,CAAC,CAAC,SAAS,IAAI,GACxB,IAAI,GACJ,KAAK,GACP,KAAK,CAAC"}

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

@@ -6,7 +6,7 @@ import { IfEqual, AfterFirst, First } from "../../index";
  * stored in `TList`. Possible results are `true`, `false`. A wide `boolean` type
  * is not possible as equality operator can always be evaluated at design time.
  *
- * **See Also:** `SomeExtends` and `IfSomeEqual`
+ * **See Also:** `SomeExtend` and `IfSomeEqual`
  */
-export type SomeEqual<TVal, TList extends readonly unknown[]> = [] extends TList ? false : IfEqual<TVal, First<TList>, true, SomeEqual<TVal, AfterFirst<TList>>>;
+export type SomeEqual<TList extends readonly unknown[], TVal> = [] extends TList ? false : IfEqual<TVal, First<TList>, true, SomeEqual<AfterFirst<TList>, TVal>>;
 //# sourceMappingURL=SomeEqual.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SomeEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/SomeEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,UAAU,EAAE,KAAK,EAAE,oBAAwB;AAE9D;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,SAAS,SAAS,OAAO,EAAE,IAAI,EAAE,SAAS,KAAK,GAC9E,KAAK,GACL,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"SomeEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/SomeEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAG,UAAU,EAAE,KAAK,EAAE,oBAAwB;AAE9D;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,CACrB,KAAK,SAAS,SAAS,OAAO,EAAE,EAC9B,IAAI,IACF,EAAE,SAAS,KAAK,GAClB,KAAK,GACL,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"SomeExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/SomeExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,oBAAwB;AAE/D,KAAK,OAAO,CACV,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,SAAS,CACP,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,EACrB,IAAI,EACJ,OAAO,CACL,UAAU,CAAC,KAAK,CAAC,EACjB,OAAO,CACR,CACF,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CACpB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,OAAO,CAAC,KAAK,EAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"SomeExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/SomeExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,oBAAwB;AAEjE,KAAK,OAAO,CACV,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,EAAE,SAAS,KAAK,GAChB,KAAK,GACL,EAAE,CACA,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAC9B,IAAI,EACJ,OAAO,CACL,UAAU,CAAC,KAAK,CAAC,EACjB,OAAO,CACR,CACF,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CACpB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,IACL,OAAO,CAAC,KAAK,EAAC,OAAO,CAAC,CAAC"}

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

@@ -1,12 +1,25 @@
-import { IfNumericLiteral, IsStringLiteral, IfString, ToString } from "../../index";
+import { AsString, IsFalse, IsEqual, IsUnion, Or } from "../../index";
+type TestThatExtends<TValue extends string, TComparator extends string> = [TValue] extends [`${TComparator}${string}`] ? true : false;
+type Process<TValue extends string, TComparator extends string> = [IsFalse<TestThatExtends<TValue, TComparator>>] extends [true] ? false : true;
+type ProcessEach<TValue extends string, TComparator extends readonly string[]> = {
+    [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> extends readonly boolean[] ? Or<ProcessEach<TValue, TComparator>> : never : TComparator extends string ? Process<TValue, AsString<TComparator>> : never;
+type IsWide<TValue extends string | number, TComparator extends string | number | readonly string[]> = [IsEqual<AsString<TValue>, string>] extends [true] ? true : [IsEqual<AsString<TComparator>, string>] extends [true] ? true : false;
 /**
- * **StartsWith**<TValue, TStartsWith>
+ * **StartsWith**<TValue, TComparator>
  *
- * A type utility which checks whether `T` _starts with_ the string literal `U`.
+ * A type utility which checks whether `TValue` _starts with_ the
+ * value of `TComparator`.
  *
- * While `T` _can_ be passed in as a non-string value this almost always resolves
- * to false. The one exception is where a numeric literal can be converted to a
- * string literal.
+ * - numeric values for `TValue` will be converted into string literals
+ * prior to comparison
+ * - a tuple value in `TComparator` is allowed and will test whether
+ * _any_ of the patterns start `TValue`
+ * - a union type for `TComparator` is allowed so long as it's only for a single character
+ *    - this can be much more type efficient for unions with lots of characters
+ *    - if you need larger pattern matches then use a Tuple for `TComparator`
  */
-export type StartsWith<TValue, TStartsWith extends string | number> = TStartsWith extends number ? StartsWith<TValue, ToString<TStartsWith>> : IfString<TValue, IsStringLiteral<TStartsWith> extends true ? IsStringLiteral<TValue> extends true ? TValue extends `${TStartsWith}${string}` ? true : false : boolean : boolean, IfNumericLiteral<TValue, TValue extends number ? StartsWith<ToString<TValue>, TStartsWith> : never, false>>;
+export type StartsWith<TValue extends string | number, TComparator extends string | number | readonly string[]> = [IsWide<TValue, TComparator>] extends [true] ? boolean : [IsUnion<TComparator>] extends [true] ? IsFalse<PreProcess<`${TValue}`, TComparator extends number ? AsString<TComparator> : TComparator>> extends true ? false : true : PreProcess<AsString<TValue>, TComparator extends number ? `${TComparator}` : TComparator>;
+export {};
 //# sourceMappingURL=StartsWith.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StartsWith.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/StartsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,gBAAgB,EAAE,eAAe,EAAG,QAAQ,EAAE,QAAQ,EAAE,oBAAwB;AAC1F;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,CACpB,MAAM,EACN,WAAW,SAAS,MAAM,GAAG,MAAM,IACjC,WAAW,SAAS,MAAM,GAC5B,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,GACzC,QAAQ,CACR,MAAM,EAEN,eAAe,CAAC,WAAW,CAAC,SAAS,IAAI,GACrC,eAAe,CAAC,MAAM,CAAC,SAAS,IAAI,GAClC,MAAM,SAAS,GAAG,WAAW,GAAG,MAAM,EAAE,GACtC,IAAI,GACJ,KAAK,GACP,OAAO,GACT,OAAO,EAEX,gBAAgB,CACd,MAAM,EACN,MAAM,SAAS,MAAM,GACjB,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,GACzC,KAAK,EACT,KAAK,CACN,CACF,CAAC"}
+{"version":3,"file":"StartsWith.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/StartsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,OAAO,EACP,OAAO,EACP,OAAO,EACP,EAAE,EACH,oBAAwB;AAEzB,KAAK,eAAe,CAClB,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,IACxB,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,WAAW,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,KAAK,CAAA;AAE/D,KAAK,OAAO,CACV,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,MAAM,IACxB,CAAC,OAAO,CAAC,eAAe,CAAC,MAAM,EAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC/D,KAAK,GACL,IAAI,CAAC;AAEP,KAAK,WAAW,CACZ,MAAM,SAAS,MAAM,EACrB,WAAW,SAAS,SAAS,MAAM,EAAE,IACrC;KACD,CAAC,IAAI,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,EAAC,WAAW,CAAC,CAAC,CAAC,CAAC;CACzD,CAAC;AAIF,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,SAAS,SAAS,OAAO,EAAE,GACzD,EAAE,CAAC,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,GACpC,KAAK,GACP,WAAW,SAAS,MAAM,GACxB,OAAO,CAAC,MAAM,EAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,GACrC,KAAK,CAAC;AAEZ,KAAK,MAAM,CACT,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,IACrD,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAC,MAAM,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACnD,IAAI,GACJ,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAC,MAAM,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACtD,IAAI,GACJ,KAAK,CAAC;AAER;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,CACpB,MAAM,SAAS,MAAM,GAAG,MAAM,EAC9B,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,IACrD,CAAC,MAAM,CAAC,MAAM,EAAC,WAAW,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7C,OAAO,GACP,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACnC,OAAO,CACL,UAAU,CACR,GAAG,MAAM,EAAE,EACX,WAAW,SAAS,MAAM,GACtB,QAAQ,CAAC,WAAW,CAAC,GACrB,WAAW,CAChB,CACF,SAAS,IAAI,GACZ,KAAK,GACL,IAAI,GACN,UAAU,CACR,QAAQ,CAAC,MAAM,CAAC,EAChB,WAAW,SAAS,MAAM,GACtB,GAAG,WAAW,EAAE,GAChB,WAAW,CAChB,CAAC"}

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

@@ -0,0 +1,20 @@
+import { AsString, ErrorCondition, IsBoolean, IsFalse, IsTrue, IsWideType, LogicFunction } from "../../index";
+type WideBooleanNotAllowed = ErrorCondition<"wide-boolean-not-allowed", `Call to Validate<T,E> received a wide boolean type for T!`>;
+type WideReturnNotAllowed<T> = ErrorCondition<"wide-return-not-allowed", `Call to Validate<T,E> returned a wide type: ${AsString<T>}!`>;
+/**
+ * **Validate**`<T,[E]>`
+ *
+ * Branching utility which proxies through the value of `T` when it is
+ * **not** `false` or _returns_ false, otherwise it passes along `E`.
+ *
+ * - `E` by default is _never_
+ * - if `T` is a wide boolean type an `ErrorCondition<"wide-boolean-not-allowed">`
+ * will be returned
+ *
+ * ```ts
+ * const fn = <T extends string>(dp: T & Validate<IsDotPath<T>>) => {}
+ * ```
+ */
+export type Validate<TTest, TErr = never> = [IsTrue<TTest>] extends [true] ? TTest : [IsFalse<TTest>] extends [true] ? TErr : [IsBoolean<TTest>] extends [true] ? WideBooleanNotAllowed : [TTest] extends [LogicFunction] ? [IsTrue<ReturnType<TTest>>] extends [true] ? TTest : [IsFalse<ReturnType<TTest>>] extends [true] ? TErr : WideBooleanNotAllowed : [IsWideType<TTest>] extends [true] ? WideReturnNotAllowed<TTest> : TTest;
+export {};
+//# sourceMappingURL=Validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Validate.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Validate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,SAAS,EACT,OAAO,EACP,MAAM,EACN,UAAU,EACV,aAAa,EACd,oBAAwB;AAGzB,KAAK,qBAAqB,GAAG,cAAc,CACzC,0BAA0B,EAC1B,2DAA2D,CAC5D,CAAC;AAEF,KAAK,oBAAoB,CAAC,CAAC,IAAI,cAAc,CAC3C,yBAAyB,EACzB,+CAA+C,QAAQ,CAAC,CAAC,CAAC,GAAG,CAC9D,CAAC;AAGF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAClB,KAAK,EACL,IAAI,GAAG,KAAK,IACV,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC9B,KAAK,GACL,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC/B,IAAI,GACJ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,qBAAqB,GACrB,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,GAC7B,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACxC,KAAK,GACP,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACzC,IAAI,GACN,qBAAqB,GACvB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAChC,oBAAoB,CAAC,KAAK,CAAC,GAC3B,KAAK,CAAC"}