inferred-types 0.42.1 → 0.43.1

package/dist/types/boolean-logic/branching/Fail.d.ts

@@ -0,0 +1,21 @@
+import { Tuple } from "../..";
+import { Or } from "../combinators";
+import { IsFalse, IsNever } from "../operators";
+type ShouldFail<TTest> = [IsNever<TTest>] extends [true] ? true : [IsFalse<TTest>] extends [true] ? true : false;
+type Iterate<TTest extends readonly unknown[]> = Or<{
+    [K in keyof TTest]: ShouldFail<[TTest[K]]>;
+}>;
+/**
+ * **Fail**`<TVal, TTest>`
+ *
+ * A branching utility which tests `TTest` for `false`, `never`, or `ErrorCondition`
+ * and if matched will set the value to `never`. If there is _not_ a match then
+ * `TVal` will be passed through.
+ *
+ * If you wish to have more than one test which might produce the failure
+ * condition you can pass in a tuple of tests into `TTest` and if _any_ of
+ * the tests fail then the condition fails.
+ */
+export type Fail<TVal, TTest> = [TTest] extends [Tuple] ? [Iterate<TTest>] extends [true] ? never : TVal : [ShouldFail<TTest>] extends [true] ? never : TVal;
+export {};
+//# sourceMappingURL=Fail.d.ts.map

package/dist/types/boolean-logic/branching/Fail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fail.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/Fail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAC9B,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGhD,KAAK,UAAU,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACtD,IAAI,GACJ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC/B,IAAI,GACJ,KAAK,CAAC;AAER,KAAK,OAAO,CACV,KAAK,SAAS,SAAS,OAAO,EAAE,IAC9B,EAAE,CAAC;KACJ,CAAC,IAAI,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC,CAAA;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,IAAI,CACd,IAAI,EACJ,KAAK,IACH,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,GACzB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,KAAK,GACL,IAAI,GACN,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAChC,KAAK,GACL,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/Handle.d.ts

@@ -0,0 +1,17 @@
+import { IsEqual, Filter, If, IsUnion, TupleToUnion, UnionToTuple } from "../../index";
+type Narrow<TContent, THandle> = IsUnion<TContent> extends true ? UnionToTuple<TContent> extends readonly unknown[] ? Filter<UnionToTuple<TContent>, THandle> extends readonly unknown[] ? TupleToUnion<Filter<UnionToTuple<TContent>, THandle>> : never : never : TContent;
+/**
+ * **Handle**`<TContent,THandle,TMapTo,[TSpecificity]>`
+ *
+ * Maps `TContent` when it _extends_ / _equals (based on `TSpecificity`) the type
+ * of `THandle` to `TMapTo`, otherwise it just proxies the value through.
+ *
+ * - `TSpecificity` defaults to _extends_ but can be set to _equals_
+ *
+ * **Related:** `THandle`
+ */
+export type Handle<TContent, THandle, TMapTo, TSpecificity extends "extends" | "equals" = "extends"> = [
+    THandle
+] extends never[] ? [TContent] extends never[] ? TMapTo : TContent : TSpecificity extends "extends" ? [TContent] extends [THandle] ? TMapTo : Narrow<TContent, THandle> : If<IsEqual<[TContent], [THandle]>, TMapTo, TContent>;
+export {};
+//# sourceMappingURL=Handle.d.ts.map

package/dist/types/boolean-logic/branching/Handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Handle.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/Handle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACN,EAAE,EACF,OAAO,EACP,YAAY,EACZ,YAAY,EACb,oBAAwB;AAEzB,KAAK,MAAM,CACT,QAAQ,EACR,OAAO,IACL,OAAO,CAAC,QAAQ,CAAC,SAAS,IAAI,GAC9B,YAAY,CAAC,QAAQ,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/C,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,SAAS,SAAS,OAAO,EAAE,GAChE,YAAY,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,GACrD,KAAK,GACT,KAAK,GACP,QAAQ,CAAC;AAGX;;;;;;;;;GASG;AACH,MAAM,MAAM,MAAM,CAChB,QAAQ,EACR,OAAO,EACP,MAAM,EACN,YAAY,SAAS,SAAS,GAAG,QAAQ,GAAG,SAAS,IAEvD;IAAC,OAAO;CAAC,SAAS,KAAK,EAAE,GACrB,CAAC,QAAQ,CAAC,SAAS,KAAK,EAAE,GACxB,MAAM,GACN,QAAQ,GACZ,YAAY,SAAS,SAAS,GAC5B,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,GAC1B,MAAM,GACN,MAAM,CAAC,QAAQ,EAAC,OAAO,CAAC,GAC1B,EAAE,CACF,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,EAC9B,MAAM,EACN,QAAQ,CACT,CAAA"}

package/dist/types/boolean-logic/branching/If.d.ts

@@ -0,0 +1,14 @@
+import { ErrorCondition, IsBoolean, IsBooleanLiteral, IsFalse, IsNever, IsTrue, LogicFunction, ProxyError, Throw } from "../../index";
+type InvalidTest<TTest> = Throw<"invalid-test", `Call of If<TTest, ...> received an invalid TTest that does not evaluate to a boolean type!`, "If", {
+    library: "inferred-types";
+    test: TTest;
+}>;
+type ReceivedError<TTest extends ErrorCondition> = ProxyError<TTest, "If", "TTest">;
+/**
+ * **If**`<TTest,[TIf],[TElse],[TMaybe]>`
+ *
+ * Branching utility which tests `TTest` for a boolean value.
+ */
+export type If<TTest, TIf = true, TElse = false, TMaybe = TIf | TElse, TNever = never> = [IsNever<TTest>] extends [true] ? TNever : [TTest] extends [ErrorCondition] ? ReceivedError<TTest> : [TTest] extends [boolean] ? [IsTrue<TTest>] extends [true] ? TIf : [IsBooleanLiteral<TTest>] extends [true] ? TElse : TMaybe : [TTest] extends [LogicFunction] ? [IsTrue<ReturnType<TTest>>] extends [true] ? TIf : [IsFalse<ReturnType<TTest>>] extends [true] ? TElse : [IsBoolean<ReturnType<TTest>>] extends [true] ? TMaybe : never : InvalidTest<TTest>;
+export {};
+//# sourceMappingURL=If.d.ts.map

package/dist/types/boolean-logic/branching/If.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"If.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/If.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,KAAK,EAAG,oBAAwB;AAE3I,KAAK,WAAW,CAAC,KAAK,IAAI,KAAK,CAC7B,cAAc,EACd,4FAA4F,EAC5F,IAAI,EACJ;IACE,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,KAAK,CAAC;CACb,CACF,CAAA;AAED,KAAK,aAAa,CAAC,KAAK,SAAS,cAAc,IAAI,UAAU,CAC3D,KAAK,EACL,IAAI,EACJ,OAAO,CACR,CAAA;AAaD;;;;GAIG;AACH,MAAM,MAAM,EAAE,CACZ,KAAK,EACL,GAAG,GAAG,IAAI,EACV,KAAK,GAAG,KAAK,EACb,MAAM,GAAG,GAAG,GAAG,KAAK,EACpB,MAAM,GAAG,KAAK,IACX,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAClC,MAAM,GACN,CAAC,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,GAC9B,aAAa,CAAC,KAAK,CAAC,GACtB,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,GACvB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC5B,GAAG,GACH,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACtC,KAAK,GACL,MAAM,GACV,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,GAC7B,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACxC,GAAG,GACL,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACzC,KAAK,GACL,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,MAAM,GACN,KAAK,GACT,WAAW,CAAC,KAAK,CAAC,CAAC"}

package/dist/types/boolean-logic/branching/IfErrorCondition.d.ts

@@ -1,4 +1,4 @@
-import { IsErrorCondition } from "../../index";
+import { ErrorConditionShape, IsErrorCondition } from "../../index";
 /**
  * **IFErrorCondition**`<T,IF,[ELSE]>`
  *
@@ -7,5 +7,5 @@ import { IsErrorCondition } from "../../index";
  *
  * **Related:** `IfError`
  */
-export type IfErrorCondition<T, IF, ELSE = T> = IsErrorCondition<T> extends true ? IF : ELSE;
+export type IfErrorCondition<T, IF, ELSE = T> = IsErrorCondition<T> extends true ? T extends ErrorConditionShape ? IF : never : ELSE;
 //# sourceMappingURL=IfErrorCondition.d.ts.map

package/dist/types/boolean-logic/branching/IfErrorCondition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IfErrorCondition.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfErrorCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAwB;AAGnD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAC,EAAE,EAAC,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1E,EAAE,GACF,IAAI,CAAC"}
+{"version":3,"file":"IfErrorCondition.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfErrorCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,oBAAwB;AAGxE;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,EACD,EAAE,EACF,IAAI,GAAG,CAAC,IACN,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAChC,CAAC,SAAS,mBAAmB,GAC3B,EAAE,GACF,KAAK,GACP,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/IfLength.d.ts

@@ -1,4 +1,4 @@
-import { Length, IfEqual, IsLiteral, Tuple, IfStringLiteral } from "../../index";
+import { Length, IfEqual, Tuple, If, IsStringLiteral, IsNumericLiteral } from "../../index";
 /**
  * **IfLength**`<TEvaluate,TLength,IF,[ELSE],[MAYBE]>`
  *
@@ -11,5 +11,5 @@ import { Length, IfEqual, IsLiteral, Tuple, IfStringLiteral } from "../../index"
  * - If a _non-array_ type is passed into `TEvaluate` then utility will result `ELSE`
  * type.
  */
-export type IfLength<TEvaluate extends Tuple | string, TLength extends number, IF, ELSE = TEvaluate, MAYBE = IF | ELSE> = TEvaluate extends readonly unknown[] ? IsLiteral<TLength> extends true ? IfEqual<Length<TEvaluate>, TLength, IF, ELSE> : MAYBE : TEvaluate extends unknown[] ? MAYBE : TEvaluate extends string ? IfStringLiteral<TEvaluate, IfEqual<Length<TEvaluate>, TLength, IF, ELSE>, MAYBE> : MAYBE;
+export type IfLength<TEvaluate extends Tuple | string, TLength extends number, IF, ELSE = TEvaluate, MAYBE = IF | ELSE> = TEvaluate extends readonly unknown[] ? IsNumericLiteral<TLength> extends true ? IfEqual<Length<TEvaluate>, TLength, IF, ELSE> : MAYBE : TEvaluate extends unknown[] ? MAYBE : TEvaluate extends string ? If<IsStringLiteral<TEvaluate>, IfEqual<Length<TEvaluate>, TLength, IF, ELSE>, MAYBE> : MAYBE;
 //# sourceMappingURL=IfLength.d.ts.map

package/dist/types/boolean-logic/branching/IfLength.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IfLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,EAAE,oBAAwB;AAGrF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,CAClB,SAAS,SAAS,KAAK,GAAG,MAAM,EAChC,OAAO,SAAS,MAAM,EACtB,EAAE,EACF,IAAI,GAAG,SAAS,EAChB,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,SAAS,SAAS,SAAS,OAAO,EAAE,GACpC,SAAS,CAAC,OAAO,CAAC,SAAS,IAAI,GAC7B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,GAC7C,KAAK,GACP,SAAS,SAAS,OAAO,EAAE,GACzB,KAAK,GACL,SAAS,SAAS,MAAM,GACtB,eAAe,CACb,SAAS,EACT,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAC7C,KAAK,CACN,GACD,KAAK,CAAC"}
+{"version":3,"file":"IfLength.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,eAAe,EAAG,gBAAgB,EAAE,oBAAwB;AAGjG;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,CAClB,SAAS,SAAS,KAAK,GAAG,MAAM,EAChC,OAAO,SAAS,MAAM,EACtB,EAAE,EACF,IAAI,GAAG,SAAS,EAChB,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,SAAS,SAAS,SAAS,OAAO,EAAE,GACpC,gBAAgB,CAAC,OAAO,CAAC,SAAS,IAAI,GACpC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,GAC7C,KAAK,GACP,SAAS,SAAS,OAAO,EAAE,GACzB,KAAK,GACL,SAAS,SAAS,MAAM,GACtB,EAAE,CACA,eAAe,CAAC,SAAS,CAAC,EAC1B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAC7C,KAAK,CACN,GACD,KAAK,CAAC"}

package/dist/types/boolean-logic/branching/IfNever.d.ts

@@ -5,5 +5,5 @@ import { IsNever } from "../../index";
  * Type utility which transforms type `T` based on whether it extends the _never_
  * type.
  */
-export type IfNever<T, IF, ELSE = T> = IsNever<T> extends true ? IF : ELSE;
+export type IfNever<T, IF, ELSE = T> = [IsNever<T>] extends [true] ? IF : ELSE;
 //# sourceMappingURL=IfNever.d.ts.map

package/dist/types/boolean-logic/branching/IfNever.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IfNever.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNever.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,EAAE,EACF,IAAI,GAAG,CAAC,IACN,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}
+{"version":3,"file":"IfNever.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNever.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,oBAAwB;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,EAAE,EACF,IAAI,GAAG,CAAC,IACN,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/types/boolean-logic/branching/Iff.d.ts

@@ -0,0 +1,24 @@
+import { AfterFirst, AsArray, Container, First, IndexOf, NonArray, Nothing, Throw } from "../..";
+type ProcessContainers<TValues extends readonly (Container | TIgnore)[], TIgnore, TOffset extends PropertyKey | null, TNotFound> = [] extends TValues ? TNotFound : IndexOf<First<TValues>, TOffset, TIgnore> extends TIgnore ? ProcessContainers<AfterFirst<TValues>, TIgnore, TOffset, TNotFound> : IndexOf<First<TValues>, TOffset>;
+type Process<TValues extends readonly unknown[], TIgnore, TNotFound> = [] extends TValues ? TNotFound : First<TValues> extends TIgnore ? Process<AfterFirst<TValues>, TIgnore, TNotFound> : First<TValues>;
+/**
+ * **Iff**`<TValues,[TIgnore],[TOffset],[TNotFound]>`
+ *
+ * Looks through a list of values -- `TValues` -- until it finds
+ * the first one which _does not_ extend `TIgnore` (which is by
+ * default set to null or undefined).
+ *
+ * If it reaches the end without finding a value to use it will
+ * fall back on the `TNotFound` value which is `ErrorCondition<"not-found">`
+ * by default.
+ */
+export type Iff<TValues extends NonArray | readonly unknown[], TIgnore = Nothing, TOffset extends PropertyKey | null = null, TNotFound = Throw<"not-found", `Call to Iff utility resulted in no valid results`, "Iff", {
+    library: "inferred-types";
+    values: AsArray<TValues>;
+}>> = TOffset extends PropertyKey ? TValues extends readonly (Container | TIgnore)[] ? ProcessContainers<AsArray<TValues>, TIgnore, TOffset, TNotFound> : Throw<"invalid-values", `When calling Iff with a TOffset set; the TValues generic must contain a tuple of containers!`, "Iff", {
+    library: "inferred-types";
+    values: AsArray<TValues>;
+    offset: TOffset;
+}> : Process<AsArray<TValues>, TIgnore, TNotFound>;
+export {};
+//# sourceMappingURL=Iff.d.ts.map

package/dist/types/boolean-logic/branching/Iff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Iff.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/Iff.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEjG,KAAK,iBAAiB,CACpB,OAAO,SAAS,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,EAAE,EAChD,OAAO,EACP,OAAO,SAAS,WAAW,GAAG,IAAI,EAClC,SAAS,IACP,EAAE,SAAS,OAAO,GACpB,SAAS,GACT,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,SAAS,OAAO,GACvD,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,EAAC,OAAO,EAAC,SAAS,CAAC,GACjE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAErC,KAAK,OAAO,CACV,OAAO,SAAS,SAAS,OAAO,EAAE,EAClC,OAAO,EACP,SAAS,IACP,EAAE,SAAS,OAAO,GACpB,SAAS,GACT,KAAK,CAAC,OAAO,CAAC,SAAS,OAAO,GAC5B,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAC,OAAO,EAAC,SAAS,CAAC,GAC9C,KAAK,CAAC,OAAO,CAAC,CAAC;AAEnB;;;;;;;;;;GAUG;AACH,MAAM,MAAM,GAAG,CACb,OAAO,SAAS,QAAQ,GAAG,SAAS,OAAO,EAAE,EAC7C,OAAO,GAAG,OAAO,EACjB,OAAO,SAAS,WAAW,GAAG,IAAI,GAAG,IAAI,EACzC,SAAS,GAAG,KAAK,CACf,WAAW,EACX,kDAAkD,EAClD,KAAK,EACL;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CACxD,IACC,OAAO,SAAS,WAAW,GAC7B,OAAO,SAAS,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,EAAE,GAC9C,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,GAChE,KAAK,CACH,gBAAgB,EAChB,8FAA8F,EAC9F,KAAK,EACL;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CACzE,GACH,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAC,OAAO,EAAC,SAAS,CAAC,CAAC"}

package/dist/types/boolean-logic/branching/Passthrough.d.ts

@@ -0,0 +1,11 @@
+import { IfEquals } from "./IfEqual";
+/**
+ * **Passthrough**`<TContent,TPass,THandle>`
+ *
+ * Passes through content in `TContent` when it _extends_ the type
+ * of `TPass`, otherwise it changes the type to `THandle`.
+ *
+ * **Related:** `THandle`
+ */
+export type Passthrough<TContent, TPass, THandle, TSpecificity extends "extends" | "equals" = "extends"> = IfEquals<TSpecificity, "extends", TContent extends TPass ? TContent : THandle, IfEquals<TContent, TPass, TContent, THandle>>;
+//# sourceMappingURL=Passthrough.d.ts.map

package/dist/types/boolean-logic/branching/Passthrough.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Passthrough.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/Passthrough.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CACrB,QAAQ,EACR,KAAK,EACL,OAAO,EACP,YAAY,SAAS,SAAS,GAAG,QAAQ,GAAG,SAAS,IACnD,QAAQ,CACV,YAAY,EAAE,SAAS,EACvB,QAAQ,SAAS,KAAK,GAClB,QAAQ,GACR,OAAO,EACX,QAAQ,CACN,QAAQ,EAAE,KAAK,EACf,QAAQ,EACR,OAAO,CACR,CACF,CAAA"}

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

@@ -1,70 +1,13 @@
 export * from "./IfAllLiteral";
-export * from "./IfScalar";
-export * from "./IfDefined";
-export * from "./IfOr";
-export * from "./IfOptionalScalar";
-export * from "./IfNull";
-export * from "./IfSymbol";
-export * from "./IfTruthy";
-export * from "./IfSomeTruthy";
 export * from "./IfAllExtend";
-export * from "./IfEmptyContainer";
-export * from "./IfLessThan";
-export * from "./IfNegativeNumber";
-export * from "./IfPositive";
-export * from "./IfError";
+export * from "./If";
 export * from "./IfErrorCondition";
-export * from "./IfNotError";
-export * from "./IfSingularNoun";
-export * from "./IfEqualLength";
-export * from "./IfSomeExtend";
-export * from "./IfDotPath";
-export * from "./IfValidDotPath";
-export * from "./IfHasCharacters";
-export * from "./IfChar";
-export * from "./IfValidKey";
-export * from "./IfBoolean";
-export * from "./IfGreaterThan";
-export * from "./IfTrue";
-export * from "./IfIndexable";
-export * from "./IfIndexAt";
-export * from "./IfNumber";
-export * from "./IfFalse";
-export * from "./IfMaybeTrue";
-export * from "./IfReadonlyObject";
-export * from "./IfMaybeFalse";
-export * from "./IfReturns";
-export * from "./IfFalsy";
-export * from "./IfObject";
-export * from "./IfContains";
-export * from "./IfReadonlyArray";
-export * from "./IfStartsWith";
-export * from "./IfArray";
-export * from "./IfAnd";
-export * from "./IfNotNever";
 export * from "./IfNever";
-export * from "./IfSomeEqual";
-export * from "./IfFnWithParams";
-export * from "./IfFnWithoutParams";
-export * from "./IfFunction";
-export * from "./IfExtends";
-export * from "./IfRef";
-export * from "./IfExtendsAll";
-export * from "./IfExtendsSome";
-export * from "./IfWide";
-export * from "./IfString";
 export * from "./IfEqual";
-export * from "./IfStringLiteral";
-export * from "./IfNumericLiteral";
-export * from "./IfBooleanLiteral";
-export * from "./IfLiteral";
-export * from "./IfNotLiteral";
 export * from "./IfLength";
-export * from "./IfObjectLiteral";
-export * from "./IfNotEqual";
-export * from "./IfUnion";
-export * from "./IfNarrowlyContains";
-export * from "./IfContainer";
-export * from "./IfUndefined";
-export * from "./IfTuple";
+export * from "./Passthrough";
+export * from "./Handle";
+export * from "./Default";
+export * from "./Iff";
+export * from "./Fail";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AAEnC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAG7B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AAEjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAE7B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,MAAM,CAAC;AACrB,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAA"}

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

@@ -1,69 +1,12 @@
 export * from "./IfAllLiteral.js";
-export * from "./IfScalar.js";
-export * from "./IfDefined.js";
-export * from "./IfOr.js";
-export * from "./IfOptionalScalar.js";
-export * from "./IfNull.js";
-export * from "./IfSymbol.js";
-export * from "./IfTruthy.js";
-export * from "./IfSomeTruthy.js";
 export * from "./IfAllExtend.js";
-export * from "./IfEmptyContainer.js";
-export * from "./IfLessThan.js";
-export * from "./IfNegativeNumber.js";
-export * from "./IfPositive.js";
-export * from "./IfError.js";
+export * from "./If.js";
 export * from "./IfErrorCondition.js";
-export * from "./IfNotError.js";
-export * from "./IfSingularNoun.js";
-export * from "./IfEqualLength.js";
-export * from "./IfSomeExtend.js";
-export * from "./IfDotPath.js";
-export * from "./IfValidDotPath.js";
-export * from "./IfHasCharacters.js";
-export * from "./IfChar.js";
-export * from "./IfValidKey.js";
-export * from "./IfBoolean.js";
-export * from "./IfGreaterThan.js";
-export * from "./IfTrue.js";
-export * from "./IfIndexable.js";
-export * from "./IfIndexAt.js";
-export * from "./IfNumber.js";
-export * from "./IfFalse.js";
-export * from "./IfMaybeTrue.js";
-export * from "./IfReadonlyObject.js";
-export * from "./IfMaybeFalse.js";
-export * from "./IfReturns.js";
-export * from "./IfFalsy.js";
-export * from "./IfObject.js";
-export * from "./IfContains.js";
-export * from "./IfReadonlyArray.js";
-export * from "./IfStartsWith.js";
-export * from "./IfArray.js";
-export * from "./IfAnd.js";
-export * from "./IfNotNever.js";
 export * from "./IfNever.js";
-export * from "./IfSomeEqual.js";
-export * from "./IfFnWithParams.js";
-export * from "./IfFnWithoutParams.js";
-export * from "./IfFunction.js";
-export * from "./IfExtends.js";
-export * from "./IfRef.js";
-export * from "./IfExtendsAll.js";
-export * from "./IfExtendsSome.js";
-export * from "./IfWide.js";
-export * from "./IfString.js";
 export * from "./IfEqual.js";
-export * from "./IfStringLiteral.js";
-export * from "./IfNumericLiteral.js";
-export * from "./IfBooleanLiteral.js";
-export * from "./IfLiteral.js";
-export * from "./IfNotLiteral.js";
 export * from "./IfLength.js";
-export * from "./IfObjectLiteral.js";
-export * from "./IfNotEqual.js";
-export * from "./IfUnion.js";
-export * from "./IfNarrowlyContains.js";
-export * from "./IfContainer.js";
-export * from "./IfUndefined.js";
-export * from "./IfTuple.js";
+export * from "./Passthrough.js";
+export * from "./Handle.js";
+export * from "./Default.js";
+export * from "./Iff.js";
+export * from "./Fail.js";

package/dist/types/boolean-logic/combinators/And.d.ts

@@ -1,15 +1,11 @@
-import { AnyFunction, AfterFirst, First, IfNarrowlyContains, IfOr, IsFalse, ReturnsFalse, LogicFunction } from "../../index";
-type _And<TConditions extends readonly (boolean | LogicFunction<TParams>)[], TParams extends readonly unknown[], TResults extends readonly boolean[] = []> = [] extends TConditions ? IfNarrowlyContains<TResults, boolean, boolean, true> : IfOr<[
-    IsFalse<First<TConditions>>,
-    ReturnsFalse<First<TConditions>>
-], false, // false short circuits
-_And<AfterFirst<TConditions>, TParams, First<TConditions> extends boolean ? [...TResults, First<TConditions>] : First<TConditions> extends AnyFunction ? ReturnType<First<TConditions>> extends boolean ? [...TResults, ReturnType<First<TConditions>>] : never : never>>;
+import { AfterFirst, First, IfEqual, IsEqual, LogicFunction, LogicalReturns, NarrowlyContains } from "../../index";
+type Process<TConditions extends readonly boolean[], TBooleanSeen extends boolean> = [] extends TConditions ? IfEqual<TBooleanSeen, true, boolean, true> : [First<TConditions>] extends [false] ? false : Process<AfterFirst<TConditions>, TBooleanSeen>;
 /**
- * **And**`<TConditions, [TParams]>`
+ * **And**`<TConditions, [TEmpty]>`
  *
  * Allows an array of conditions which are either ARE a boolean value or a
  * function which evaluates to a boolean value to be logically AND'd together.
  */
-export type And<TConditions extends readonly (boolean | LogicFunction<TParams>)[], TParams extends readonly unknown[] = []> = _And<TConditions, TParams>;
+export type And<TConditions extends readonly (boolean | LogicFunction)[], TEmpty extends boolean = false> = IsEqual<TConditions, []> extends true ? TEmpty : LogicalReturns<TConditions> extends readonly boolean[] ? Process<LogicalReturns<TConditions>, NarrowlyContains<LogicalReturns<TConditions>, boolean>> : never;
 export {};
 //# sourceMappingURL=And.d.ts.map

package/dist/types/boolean-logic/combinators/And.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"And.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/And.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAG,kBAAkB,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,oBAAwB;AAElI,KAAK,IAAI,CACP,WAAW,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EACjE,OAAO,SAAS,SAAS,OAAO,EAAE,EAClC,QAAQ,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACtC,EAAE,SAAS,WAAW,GACxB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,GACpD,IAAI,CACF;IACE,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IAAE,YAAY,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;CAC9D,EACD,KAAK,EAAE,uBAAuB;AAC9B,IAAI,CACF,UAAU,CAAC,WAAW,CAAC,EACvB,OAAO,EACP,KAAK,CAAC,WAAW,CAAC,SAAS,OAAO,GAC9B,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,GACjC,KAAK,CAAC,WAAW,CAAC,SAAS,WAAW,GACpC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,SAAS,OAAO,GAC5C,CAAC,GAAG,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,GAC7C,KAAK,GACP,KAAK,CACZ,CACF,CAAC;AAGJ;;;;;GAKG;AACH,MAAM,MAAM,GAAG,CACb,WAAW,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EACjE,OAAO,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACrC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC"}
+{"version":3,"file":"And.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/And.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,KAAK,EACL,OAAO,EACP,OAAO,EACP,aAAa,EACb,cAAc,EACd,gBAAgB,EACjB,oBAAwB;AAEzB,KAAK,OAAO,CACV,WAAW,SAAS,SAAS,OAAO,EAAE,EACtC,YAAY,SAAS,OAAO,IAC1B,EAAE,SAAS,WAAW,GACxB,OAAO,CAAC,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,GAC1C,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAClC,KAAK,GACL,OAAO,CACL,UAAU,CAAC,WAAW,CAAC,EACvB,YAAY,CACb,CAAC;AAGN;;;;;GAKG;AACH,MAAM,MAAM,GAAG,CACb,WAAW,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,EACxD,MAAM,SAAS,OAAO,GAAG,KAAK,IAC5B,OAAO,CAAC,WAAW,EAAC,EAAE,CAAC,SAAS,IAAI,GACtC,MAAM,GACN,cAAc,CAAC,WAAW,CAAC,SAAS,SAAS,OAAO,EAAE,GACpD,OAAO,CACL,cAAc,CAAC,WAAW,CAAC,EAC3B,gBAAgB,CAAC,cAAc,CAAC,WAAW,CAAC,EAAC,OAAO,CAAC,CACtD,GACD,KAAK,CAAC"}

package/dist/types/boolean-logic/combinators/Compare.d.ts

@@ -0,0 +1,47 @@
+import { Contains, DoesExtend, IsEqual, StartsWith, TupleToUnion, EndsWith, Tuple, ErrorCondition, Extends, NumberLike, TypedFunction } from "../../index";
+/**
+ * **ComparatorOperation**
+ *
+ * A union type providing various ways in which two values
+ * can be compared.
+ */
+export type ComparatorOperation = "extends" | "equals" | "startsWith" | "endsWith" | "contains" | "containsAll" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "returnEquals" | "returnExtends";
+/**
+ * **ParamsForComparison**`<T>`
+ *
+ * Provides a lookup function on `T` of the _parameters_ required
+ * for a given `ComparatorOperation`.
+ */
+export type ParamsForComparison<T extends ComparatorOperation> = T extends "equals" ? readonly [unknown] : T extends "extends" ? readonly [unknown] : T extends "startsWith" ? [string | number] : T extends "endsWith" ? readonly [[string | number] | Tuple<unknown, 1>] : T extends "contains" ? readonly [unknown, ...Tuple[]] : T extends "containsAll" ? readonly [unknown, ...Tuple[]] : T extends "greaterThan" ? readonly [NumberLike] : T extends "greaterThanOrEqual" ? readonly [NumberLike] : T extends "lessThan" ? readonly [NumberLike] : T extends "lessThanOrEqual" ? readonly [NumberLike] : never;
+/**
+ * **Comparison**`<TOp,TArgs>`
+ *
+ * A strongly typed comparison which can be used in runtime utilities
+ * like `filter`, `retain`, and `map`.
+ *
+ * - typically generated with the `createComparison(op,...params)` runtime utility.
+ *
+ * ```ts
+ * // Comparison<"equals",[true]>
+ * const isTrue = createComparison("equals", true);
+ * //
+ * const filtered = filter(isTrue)(listOfStuff);
+ * ```
+ */
+export type Comparison<TOp extends ComparatorOperation = ComparatorOperation, TArgs extends ParamsForComparison<TOp> = ParamsForComparison<TOp>, TFn extends TypedFunction = TypedFunction> = Extends<TArgs, ParamsForComparison<TOp>> extends true ? {
+    kind: "Comparison";
+    op: TOp;
+    args: TArgs;
+    fn: TFn;
+} : ErrorCondition<"invalid-comparison">;
+type Unionize<T> = T extends readonly unknown[] ? TupleToUnion<T> : T;
+type Process<TVal, TOp extends ComparatorOperation, TComparator> = TOp extends "extends" ? DoesExtend<TVal, Unionize<TComparator>> : TOp extends "equals" ? IsEqual<TVal, Unionize<TComparator>> : TOp extends "contains" ? [TVal] extends [string | number | Tuple] ? Contains<TVal, TComparator> : never : TOp extends "containsAll" ? [TVal] extends [Tuple] ? [TComparator] extends [string | number | readonly string[]] ? Contains<TVal, TComparator> : never : never : TOp extends "startsWith" ? [TVal] extends [string | number] ? [TComparator] extends [string | number | readonly string[]] ? StartsWith<TVal, TComparator> : never : never : TOp extends "endsWith" ? [TVal] extends [string | number] ? [TComparator] extends [string | number | readonly string[]] ? EndsWith<TVal, TComparator> : never : never : TOp extends "returnEquals" ? TVal extends ((...args: any[]) => any) ? IsEqual<ReturnType<TVal>, TComparator> : false : TOp extends "returnExtends" ? TVal extends ((...args: any[]) => any) ? IsEqual<ReturnType<TVal>, TComparator> : false : never;
+/**
+ * **Compare**`<TVal,TOp,TComparator>`
+ *
+ * Compares the value `TVal` with `TComparator` using
+ * the `TOp` _operator_.
+ */
+export type Compare<TVal, TOp extends ComparatorOperation, TComparator> = Process<TVal, TOp, TComparator>;
+export {};
+//# sourceMappingURL=Compare.d.ts.map

package/dist/types/boolean-logic/combinators/Compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compare.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/Compare.ts"],"names":[],"mappings":"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"}

package/dist/types/boolean-logic/combinators/Not.d.ts

@@ -1,11 +1,12 @@
-import { Tuple, LogicFunction, IfFalse, IfTrue, IsErrorCondition, AfterFirst, First } from "../../index";
-type Negate<TVal, TParams extends Tuple> = TVal extends boolean ? IfTrue<TVal, false, IfFalse<TVal, true, boolean>> : TVal extends LogicFunction<TParams> ? ReturnType<LogicFunction<TParams>> : never;
-type NegateTuple<TTuple extends readonly (boolean | LogicFunction)[], TParams extends Tuple, TResults extends readonly (boolean | LogicFunction)[] = []> = [] extends TTuple ? TResults : NegateTuple<AfterFirst<TTuple>, TParams, [
+import { LogicFunction, IsFalse, IsTrue, IsErrorCondition, AfterFirst, First, IsEqual, IsNever } from "../../index";
+type Negate<TVal> = IsNever<TVal> extends true ? never : [TVal] extends [boolean] ? IsTrue<TVal> extends true ? false : IsFalse<TVal> extends true ? true : boolean : [TVal] extends [LogicFunction] ? ReturnType<LogicFunction> : never;
+type NegateTuple<TTuple extends readonly (boolean | LogicFunction)[], TResults extends readonly (boolean | LogicFunction)[] = []> = [] extends TTuple ? IsEqual<TResults, [], false, TResults> : NegateTuple<AfterFirst<TTuple>, [
     ...TResults,
-    Negate<First<TTuple>, TParams>
+    Negate<First<TTuple>>
 ]>;
+type Process<TVal, TError = never> = IsErrorCondition<TVal> extends true ? TError : [IsNever<TVal>] extends [true] ? never : [TVal] extends [boolean] ? Negate<TVal> : TVal extends readonly (boolean | LogicFunction)[] ? NegateTuple<TVal> : never;
 /**
- * **Not**`<T>`
+ * **Not**`<T,[TError]>`
  *
  * A boolean negation that can work on both a single value or an
  * array of values.
@@ -17,6 +18,6 @@ type NegateTuple<TTuple extends readonly (boolean | LogicFunction)[], TParams ex
  * type Multi = Not<[true,false,boolean]>;
  * ```
  */
-export type Not<TVal, TParams extends Tuple = []> = IsErrorCondition<TVal> extends true ? TVal : TVal extends boolean ? Negate<TVal, TParams> : TVal extends readonly (boolean | LogicFunction)[] ? NegateTuple<TVal, TParams> : never;
+export type Not<TVal, TError = never> = Process<TVal, TError> extends boolean | readonly unknown[] ? Process<TVal, TError> : never;
 export {};
 //# sourceMappingURL=Not.d.ts.map

package/dist/types/boolean-logic/combinators/Not.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Not.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/Not.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,KAAK,EAAE,oBAAwB;AAI7G,KAAK,MAAM,CACT,IAAI,EACJ,OAAO,SAAS,KAAK,IACnB,IAAI,SAAS,OAAO,GACtB,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,GACjD,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,GACjC,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAClC,KAAK,CAAC;AAEV,KAAK,WAAW,CACd,MAAM,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,EACnD,OAAO,SAAS,KAAK,EACrB,QAAQ,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,GAAG,EAAE,IACxD,EAAE,SAAS,MAAM,GACnB,QAAQ,GACR,WAAW,CACT,UAAU,CAAC,MAAM,CAAC,EAClB,OAAO,EACP;IAAC,GAAG,QAAQ;IAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAAE,CAC/C,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,GAAG,CACb,IAAI,EACJ,OAAO,SAAS,KAAK,GAAG,EAAE,IACxB,gBAAgB,CAAC,IAAI,CAAC,SAAS,IAAI,GACnC,IAAI,GACJ,IAAI,SAAS,OAAO,GAClB,MAAM,CAAC,IAAI,EAAC,OAAO,CAAC,GACpB,IAAI,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,GAC/C,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,GAC1B,KAAK,CAAC"}
+{"version":3,"file":"Not.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/Not.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,OAAO,EACP,MAAM,EACN,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,OAAO,EACP,OAAO,EACR,oBAAwB;AAIzB,KAAK,MAAM,CACT,IAAI,IACF,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,GAC5B,KAAK,GACL,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GACtB,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,GACvB,KAAK,GACL,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,GAAI,IAAI,GAAG,OAAO,GAC9C,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAC5B,UAAU,CAAC,aAAa,CAAC,GACzB,KAAK,CAAC;AAEZ,KAAK,WAAW,CACd,MAAM,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,EACnD,QAAQ,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,GAAG,EAAE,IACxD,EAAE,SAAS,MAAM,GACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,GACtC,WAAW,CACT,UAAU,CAAC,MAAM,CAAC,EAClB;IAAC,GAAG,QAAQ;IAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;CAAE,CACtC,CAAC;AAEJ,KAAK,OAAO,CACZ,IAAI,EACJ,MAAM,GAAG,KAAK,IACV,gBAAgB,CAAC,IAAI,CAAC,SAAS,IAAI,GACrC,MAAM,GACN,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC5B,KAAK,GACL,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GACtB,MAAM,CAAC,IAAI,CAAC,GACb,IAAI,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,GAC9C,WAAW,CAAC,IAAI,CAAC,GACjB,KAAK,CAAC;AAEd;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,GAAG,CACb,IAAI,EACJ,MAAM,GAAG,KAAK,IACZ,OAAO,CAAC,IAAI,EAAC,MAAM,CAAC,SAAS,OAAO,GAAG,SAAS,OAAO,EAAE,GAC3D,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,GACrB,KAAK,CAAC"}

package/dist/types/boolean-logic/combinators/Or.d.ts

@@ -1,9 +1,20 @@
-import { LogicFunction, ReturnTypes, NarrowlyContains } from "../../index";
+import { LogicFunction, NarrowlyContains, LogicalReturns, IsNever, IsEqual, Throw, ProxyError, ErrorCondition, IsErrorCondition } from "../../index";
+type Process<TConditions extends readonly boolean[], TBooleanSean extends boolean> = NarrowlyContains<TConditions, true> extends true ? true : [IsEqual<TBooleanSean, true>] extends [true] ? boolean : false;
+type ConditionError<TErr> = TErr extends ErrorCondition ? ProxyError<TErr, "Or", "TConditions"> : never;
 /**
- * **Or**`<TConditions, TParams>`
+ * **Or**`<TConditions, [TEmpty]>`
  *
- * Allows an array of conditions which are either ARE a boolean value or a
- * function which evaluates to a boolean value to be logically AND'd together.
+ * Allows an array of conditions (either a boolean value or a
+ * function which evaluates to a boolean value) to be logically OR'd together.
+ *
+ * - by default if an empty tuple of conditions is passed in then this utility
+ * resolves to `false` but this can be changed by modifying `TEmpty`
+ *
+ * **Related:** `And`
  */
-export type Or<TConditions extends readonly (boolean | LogicFunction<TParams>)[], TParams extends readonly unknown[] = []> = NarrowlyContains<TConditions, true> extends true ? true : NarrowlyContains<ReturnTypes<TConditions>, true> extends true ? true : NarrowlyContains<TConditions, boolean> extends true ? boolean : NarrowlyContains<ReturnTypes<TConditions>, boolean> extends true ? boolean : NarrowlyContains<TConditions, false> extends true ? false : NarrowlyContains<ReturnTypes<TConditions>, false> extends true ? false : never;
+export type Or<TConditions, TEmpty extends boolean = false> = IsNever<TConditions> extends true ? Throw<"invalid-never", `Or<TConditions> received "never" for it's conditions!`, "Or"> : IsEqual<TConditions, []> extends true ? TEmpty : TConditions extends readonly (boolean | LogicFunction)[] ? LogicalReturns<TConditions> extends readonly boolean[] ? Process<LogicalReturns<TConditions>, NarrowlyContains<LogicalReturns<TConditions>, boolean>> : never : IsErrorCondition<TConditions> extends true ? ConditionError<TConditions> : Throw<"invalid-conditions", `The conditions passed to Or<TConditions> were invalid!`, "Or", {
+    library: "inferred-types";
+    value: TConditions;
+}>;
+export {};
 //# sourceMappingURL=Or.d.ts.map

package/dist/types/boolean-logic/combinators/Or.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Or.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/Or.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAG,gBAAgB,EAAG,oBAAwB;AAEjF;;;;;GAKG;AACH,MAAM,MAAM,EAAE,CAEZ,WAAW,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EACjE,OAAO,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACrC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,IAAI,GAE9C,IAAI,GAEJ,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,SAAS,IAAI,GACzD,IAAI,GAEJ,gBAAgB,CAAC,WAAW,EAAE,OAAO,CAAC,SAAS,IAAI,GACjD,OAAO,GAEP,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAC9D,OAAO,GAEP,gBAAgB,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,IAAI,GAC/C,KAAK,GAEL,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,IAAI,GAC5D,KAAK,GAEL,KAAK,CAAC"}
+{"version":3,"file":"Or.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/Or.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,OAAO,EACP,OAAO,EACP,KAAK,EACL,UAAU,EACV,cAAc,EACd,gBAAgB,EACjB,oBAAwB;AAEzB,KAAK,OAAO,CACV,WAAW,SAAS,SAAS,OAAO,EAAE,EACtC,YAAY,SAAS,OAAO,IAC1B,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,SAAS,IAAI,GAClD,IAAI,GACJ,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC1C,OAAO,GACP,KAAK,CAAC;AAEV,KAAK,cAAc,CAAC,IAAI,IAAI,IAAI,SAAS,cAAc,GACrD,UAAU,CACV,IAAI,EACJ,IAAI,EACJ,aAAa,CACd,GACC,KAAK,CAAC;AAGR;;;;;;;;;;GAUG;AACH,MAAM,MAAM,EAAE,CACZ,WAAW,EACX,MAAM,SAAS,OAAO,GAAG,KAAK,IAC5B,OAAO,CAAC,WAAW,CAAC,SAAS,IAAI,GACnC,KAAK,CACL,eAAe,EACf,uDAAuD,EACvD,IAAI,CACH,GACD,OAAO,CAAC,WAAW,EAAC,EAAE,CAAC,SAAS,IAAI,GAClC,MAAM,GACN,WAAW,SAAS,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,EAAE,GACtD,cAAc,CAAC,WAAW,CAAC,SAAS,SAAS,OAAO,EAAE,GACpD,OAAO,CACL,cAAc,CAAC,WAAW,CAAC,EAC3B,gBAAgB,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CACvD,GACD,KAAK,GACP,gBAAgB,CAAC,WAAW,CAAC,SAAS,IAAI,GACxC,cAAc,CAAC,WAAW,CAAC,GAC3B,KAAK,CACH,oBAAoB,EACpB,wDAAwD,EACxD,IAAI,EACJ;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,CAClD,CAAC"}

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

@@ -1,4 +1,5 @@
 export * from "./And";
 export * from "./Or";
 export * from "./Not";
+export * from "./Compare";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/combinators/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,MAAM,CAAC;AACrB,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC"}

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

@@ -1,3 +1,4 @@
 export * from "./And.js";
 export * from "./Or.js";
 export * from "./Not.js";
+export * from "./Compare.js";

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

@@ -0,0 +1,7 @@
+/**
+ * **As**`<TContent,TType>`
+ *
+ * Ensures that `TContent` _extends_ `TType` or turns type to `never`.
+ */
+export type As<TContent, TType> = TContent extends TType ? TContent : never;
+//# sourceMappingURL=As.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"As.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/As.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,EAAE,CAAC,QAAQ,EAAE,KAAK,IAAI,QAAQ,SAAS,KAAK,GACtD,QAAQ,GACR,KAAK,CAAC"}

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

@@ -0,0 +1,12 @@
+import { Fn } from "../../functions/Fn";
+/**
+ * **AsDoneFn**`<T>`
+ *
+ * Narrows
+ */
+export type AsDoneFn<T> = T extends {
+    done: Fn;
+} ? T & {
+    done: () => unknown;
+} : never;
+//# sourceMappingURL=AsDoneFn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AsDoneFn.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/AsDoneFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,2BAA+B;AAI5C;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,EAAE,CAAA;CAAE,GAC5C,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,OAAO,CAAA;CAAE,GAC3B,KAAK,CAAC"}

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

@@ -1,13 +1,9 @@
 import { Constant } from "../../../constants/index";
-import { Concat, Container, ErrorCondition, IfEqual, ToString } from "../../index";
+import { IfEqual, Dictionary, Throw, ToString, Tuple } from "../../index";
 /**
  * **AsIndexOf**`<T,K,[ERR]>`
  *
  * Validates that `K` is a keyof `T` and
  */
-export type AsIndexOf<T extends Container, K extends PropertyKey, ERR = Constant<"NoErr">> = K extends keyof T ? T[K] : IfEqual<ERR, Constant<"NoErr">, ErrorCondition<"invalid-key", Concat<[
-    "the key '",
-    ToString<K>,
-    "' is not a valid key of the passed container"
-]>>, ERR>;
+export type AsIndexOf<T extends Dictionary | object | Tuple, K extends PropertyKey, ERR = Constant<"NoErr">> = K extends keyof T ? T[K] : IfEqual<ERR, Constant<"NoErr">, Throw<"invalid-key", `the key '${ToString<K>}' is not a valid key of the passed container`, "AsIndexOf">, ERR>;
 //# sourceMappingURL=AsIndexOf.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AsIndexOf.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/AsIndexOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iCAA4B;AAC/C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAEvF;;;;GAIG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,WAAW,EACrB,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,IACrB,CAAC,SAAS,MAAM,CAAC,GACnB,CAAC,CAAC,CAAC,CAAC,GACJ,OAAO,CACL,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,EACtB,cAAc,CACZ,aAAa,EACb,MAAM,CAAC;IACL,WAAW;IACX,QAAQ,CAAC,CAAC,CAAC;IACX,8CAA8C;CAC/C,CAAC,CACH,EACD,GAAG,CACJ,CAAC"}
+{"version":3,"file":"AsIndexOf.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/narrowing/AsIndexOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iCAA4B;AAC/C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,oBAAwB;AAE9E;;;;GAIG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,SAAS,UAAU,GAAG,MAAM,GAAG,KAAK,EACrC,CAAC,SAAS,WAAW,EACrB,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,IACrB,CAAC,SAAS,MAAM,CAAC,GACnB,CAAC,CAAC,CAAC,CAAC,GACJ,OAAO,CACL,GAAG,EAAE,QAAQ,CAAC,OAAO,CAAC,EACtB,KAAK,CACH,aAAa,EACb,YAAY,QAAQ,CAAC,CAAC,CAAC,8CAA8C,EACrE,WAAW,CACZ,EACD,GAAG,CACJ,CAAC"}