inferred-types 0.42.0 → 0.43.0

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

@@ -1,8 +0,0 @@
-import { IsTuple, Tuple } from "../../index";
-/**
- * **IfNotTuple**`<T,[TIf],[TElse]>`
- *
- * Branching utility based on whether `T` is a Tuple.
- */
-export type IfNotTuple<T, TIf = Exclude<T, Tuple>, TElse = T & Tuple> = IsTuple<T> extends true ? TIf : TElse;
-//# sourceMappingURL=IfNotTuple.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfNotTuple.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNotTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,oBAAwB;AAEjD;;;;GAIG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,EACD,GAAG,GAAG,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,EACvB,KAAK,GAAG,CAAC,GAAG,KAAK,IACf,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACzB,GAAG,GACH,KAAK,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsNull } from "../../index";
-/**
- * **IfNull**`<T,IF,ELSE>`
- *
- * Type utility which converts type `T` to `IF` or `ELSE` based on whether
- * `T` is of type **null**.
- */
-export type IfNull<T, IF, ELSE> = IsNull<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfNull.d.ts.map

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

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

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

@@ -1,9 +0,0 @@
-import { IsNumber } from "../../index";
-/**
- * **IfNumber**`<T,IF,ELSE>`
- *
- * Type branching utility which returns `IF` type when `T` is
- * a number type (wide or narrow).
- */
-export type IfNumber<T, IF, ELSE> = IsNumber<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfNumber.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAC3C;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GACxD,EAAE,GACF,IAAI,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsNumericLiteral } from "../../index";
-/**
- * **IfNumericLiteral**`<T,IF,ELSE>`
- *
- * Branch utility which returns `IF` type when `T` is a numeric
- * literal and `ELSE` in all other situations.
- */
-export type IfNumericLiteral<T, IF, ELSE> = IsNumericLiteral<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfNumericLiteral.d.ts.map

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

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

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

@@ -1,9 +0,0 @@
-import { IsObject } from "../../index";
-/**
- * **IfObject**
- *
- * Branch type utility with return `IF` when `T` extends an object type
- * and `ELSE` otherwise
- */
-export type IfObject<T, IF, ELSE> = IsObject<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfObject.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GACxD,EAAE,GACF,IAAI,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsObjectLiteral } from "../../index";
-/**
- * **IfObjectLiteral**`<T,IF,ELSE>`
- *
- * Branching utility which returns `IF` when `T` is an object literal;
- * otherwise returns `ELSE`.
- */
-export type IfObjectLiteral<T, IF, ELSE> = IsObjectLiteral<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfObjectLiteral.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfObjectLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfObjectLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,oBAAwB;AAElD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GACxE,EAAE,GACF,IAAI,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsScalar } from "../../index";
-/**
- * **IfOptionalScalar**`<T, IF, ELSE>`
- *
- * Branch type utility which returns `IF` when `T` is a scalar value _or_ `undefined`
- * and `ELSE` otherwise
- */
-export type IfOptionalScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfOptionalScalar.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfOptionalScalar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfOptionalScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,EACD,EAAE,EACF,IAAI,IACF,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,12 +0,0 @@
-import { LogicFunction, Or } from "../../index";
-/**
- * **IfOr**`<TConditions, IF, ELSE, [TParams]>`
- *
- * Type utility which converts a set conditions [`TConditions`] to the type `IF` _if_ any
- * of the conditions evaluate to `true`, otherwise to the type `ELSE`.
- *
- * If you are evaluating functions which have params you can also specify the `TParams`
- * param which will try to use this to help narrow types where possible.
- */
-export type IfOr<TConditions extends (readonly (boolean | LogicFunction<TParams>)[]) | (boolean | LogicFunction<TParams>)[], IF, ELSE, TParams extends readonly unknown[] = []> = Or<readonly [...TConditions]> extends true ? IF : ELSE;
-//# sourceMappingURL=IfOr.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfOr.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfOr.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,oBAAwB;AAGpD;;;;;;;;GAQG;AACH,MAAM,MAAM,IAAI,CACd,WAAW,SAAS,CAAC,SAAS,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,GAC/D,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EACxC,EAAE,EACF,IAAI,EACJ,OAAO,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACrC,EAAE,CAAC,SAAS,CAAC,GAAG,WAAW,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,10 +0,0 @@
-import { LessThan } from "../../numeric-literals/LessThan";
-/**
- * **IfPositive**`<TVal,TIf,[TElse]>`
- *
- * Branching utility which return `TIf` when `TVal` is _greater than or equal_ to 0.
- *
- * **Related:** `IfLessThan`
- */
-export type IfPositive<TVal extends number, TIf, TElse extends TVal> = LessThan<TVal, 0> extends true ? TElse : TIf;
-//# sourceMappingURL=IfPositive.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfPositive.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfPositive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,wCAA4C;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CACpB,IAAI,SAAS,MAAM,EACnB,GAAG,EACH,KAAK,SAAS,IAAI,IAChB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,IAAI,GAChC,KAAK,GACL,GAAG,CAAC"}

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

@@ -1,8 +0,0 @@
-import { IsReadonlyArray } from "../../index";
-/**
- * **IfReadonlyArray**`<T, IF, ELSE>`
- *
- * Type utility which convert to type `IF` or `ELSE` based on whether `T` is a readonly array
- */
-export type IfReadonlyArray<T, IF, ELSE> = IsReadonlyArray<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfReadonlyArray.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfReadonlyArray.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfReadonlyArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,oBAAwB;AAElD;;;;GAIG;AACH,MAAM,MAAM,eAAe,CACzB,CAAC,EACD,EAAE,EACF,IAAI,IACF,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,3 +0,0 @@
-import { IsReadonlyObject } from "../../index";
-export type IfReadonlyObject<T, IF, ELSE> = IsReadonlyObject<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfReadonlyObject.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfReadonlyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfReadonlyObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,oBAAwB;AAEnD,MAAM,MAAM,gBAAgB,CAC1B,CAAC,EACD,EAAE,EACF,IAAI,IACF,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsRef } from "../../index";
-/**
- * **IfRef**`<T,IF,ELSE,[MAYBE]>`
- *
- * Conditional type utility that reacts to whether `T` _is_ or _is not_ a
- * VueJS `Ref` type.
- */
-export type IfRef<T, IF, ELSE, MAYBE = IF | ELSE> = IsRef<T> extends true ? IF : IsRef<T> extends false ? ELSE : MAYBE;
-//# sourceMappingURL=IfRef.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfRef.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAwB;AAExC;;;;;GAKG;AACH,MAAM,MAAM,KAAK,CACf,CAAC,EACD,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC"}

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

@@ -1,9 +0,0 @@
-import { AnyFunction } from "../../index";
-/**
- * **IfReturns**`<TFn,TExpected,IF,ELSE>`
- *
- * Type branching utility which returns `IF` when `TFn` is a function _and_
- * the function's return type extends `TExpected`.
- */
-export type IfReturns<TFn, TExpected, IF, ELSE> = TFn extends AnyFunction ? ReturnType<TFn> extends TExpected ? IF : ELSE : never;
-//# sourceMappingURL=IfReturns.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfReturns.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfReturns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAI9C;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,IAAI,GAAG,SAAS,WAAW,GACrE,UAAU,CAAC,GAAG,CAAC,SAAS,SAAS,GAC/B,EAAE,GACF,IAAI,GACN,KAAK,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsScalar } from "../../index";
-/**
- * **IfScalar**`<T, IF, ELSE>`
- *
- * Branch type utility which returns `IF` when `T` is a scalar value
- * (aka, string, number, or boolean) and `ELSE` otherwise
- */
-export type IfScalar<T, IF, ELSE> = IsScalar<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfScalar.d.ts.map

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

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

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

@@ -1,8 +0,0 @@
-import { IfFalse, IfTrue, IsSingularNoun } from "../../index";
-/**
- * **IfSingularNoun**`<T,IF,ELSE,[MAYBE]>`
- *
- * Branching utility based on whether `T` is a singular noun.
- */
-export type IfSingularNoun<T, IF, ELSE, MAYBE = IF | ELSE> = IfTrue<IsSingularNoun<T>, IF, IfFalse<IsSingularNoun<T>, ELSE, MAYBE>>;
-//# sourceMappingURL=IfSingularNoun.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfSingularNoun.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfSingularNoun.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,oBAAwB;AAElE;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,EAAE,GAAG,IAAI,IACzD,MAAM,CACJ,cAAc,CAAC,CAAC,CAAC,EACjB,EAAE,EACF,OAAO,CACL,cAAc,CAAC,CAAC,CAAC,EACjB,IAAI,EACJ,KAAK,CACN,CACF,CAAC"}

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

@@ -1,9 +0,0 @@
-import { SomeEqual } from "../../index";
-/**
- * **IfSomeEqual**`<Value, CompareTo, IF, ELSE>`
- *
- * A type utility which evaluates whether `Value` is equal to any of the values in
- * `CompareTo` and if so then it returns `IF` otherwise `ELSE`.
- */
-export type IfSomeEqual<Value, CompareTo extends readonly unknown[], IF, ELSE> = SomeEqual<Value, CompareTo> extends true ? IF : ELSE;
-//# sourceMappingURL=IfSomeEqual.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfSomeEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfSomeEqual.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,oBAAwB;AAE5C;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CACrB,KAAK,EACL,SAAS,SAAS,SAAS,OAAO,EAAE,EACpC,EAAE,EACF,IAAI,IACF,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,12 +0,0 @@
-import { SomeExtend } from "../../index";
-/**
- * **IfSomeExtend**`<TList,TExtend,IF,ELSE>`
- *
- * Branching type util which returns `IF` if **some** of the elements in
- * `TList` extend `TExtend`.
- *
- * - this is an inverted branching util from `IfExtendsSome`
- * - a closer comparison is `IfAllExtend` which requires all items to extend
- */
-export type IfSomeExtend<TList extends readonly unknown[], TExtend, IF, ELSE> = SomeExtend<TList, TExtend> extends true ? IF : ELSE;
-//# sourceMappingURL=IfSomeExtend.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfSomeExtend.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfSomeExtend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,oBAAwB;AAE7C;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,SAAS,OAAO,EAAE,EAChC,OAAO,EACP,EAAE,EACF,IAAI,IACF,UAAU,CAAC,KAAK,EAAC,OAAO,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,11 +0,0 @@
-import { AfterFirst, First, IfTrue, IfTruthy } from "../../index";
-/**
- * **IfSomeTruthy**`<TValues,IF,ELSE,MAYBE>`
- *
- * A type utility which evaluates all the values in `TValues` for _[truthiness](https://frontend.turing.edu/lessons/module-1/js-truthy-falsy-expressions.html)_ and
- * returns `TRUE` type when at least one is truthy, the `FALSE` type when none are,
- * and the `MAYBE` type when the truthiness is not known at design time.
- */
-export type IfSomeTruthy<TValues extends readonly unknown[], IF, ELSE, MAYBE = unknown, IsUnknown extends boolean = false> = [
-] extends TValues ? IfTrue<IsUnknown, MAYBE, ELSE> : IfTruthy<First<TValues>, true, IfSomeTruthy<AfterFirst<TValues>, IF, ELSE, MAYBE, IsUnknown>, IfSomeTruthy<AfterFirst<TValues>, IF, ELSE, MAYBE, true>>;
-//# sourceMappingURL=IfSomeTruthy.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfSomeTruthy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfSomeTruthy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,EAAG,MAAM,EAAG,QAAQ,EAAE,oBAAwB;AAExE;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,CACtB,OAAO,SAAS,SAAS,OAAO,EAAE,EAClC,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,OAAO,EACf,SAAS,SAAS,OAAO,GAAG,KAAK,IAEnC;CAAE,SAAS,OAAO,GACd,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,GAC9B,QAAQ,CACR,KAAK,CAAC,OAAO,CAAC,EACd,IAAI,EACJ,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,EAC7D,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CACzD,CAAC"}

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

@@ -1,13 +0,0 @@
-import { ToString, StartsWith } from "../../index";
-/**
- * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
- *
- * Type utility which converts type to `IF` type _if_ TValue _starts with_ `TStartsWith` but
- * otherwise converts type to `ELSE`.
- *
- * Note, that there is also an optional `MAYBE` type
- * which can be stated for cases where TValue or TStartsWith _might_ be the wider `string`
- * type and therefore the type is unknown at design time.
- */
-export type IfStartsWith<TValue, TStartsWith, IF, ELSE> = TStartsWith extends string ? StartsWith<TValue, TStartsWith> extends true ? IF : StartsWith<TValue, TStartsWith> extends false ? ELSE : IF | ELSE : TStartsWith extends number ? number extends TStartsWith ? never : IfStartsWith<TValue, ToString<TStartsWith>, IF, ELSE> : never;
-//# sourceMappingURL=IfStartsWith.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfStartsWith.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfStartsWith.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAG,UAAU,EAAE,oBAAwB;AAExD;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,CACtB,MAAM,EACN,WAAW,EACX,EAAE,EACF,IAAI,IACF,WAAW,SAAS,MAAM,GAEtB,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,SAAS,IAAI,GAC1C,EAAE,GACF,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,SAAS,KAAK,GAC7C,IAAI,GACJ,EAAE,GAAG,IAAI,GAEX,WAAW,SAAS,MAAM,GACtB,MAAM,SAAS,WAAW,GACxB,KAAK,GACL,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,GACvD,KAAK,CAAC"}

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

@@ -1,10 +0,0 @@
-import { IsString } from "../../index";
-/**
- * **IfString**`<T,TRUE,FALSE>`
- *
- * Type utility which determines if `T` is a _string_ (wide or narrow) and
- * returns `TRUE` type if it is, otherwise returns the type `FALSE`.
- */
-export type IfString<T, //
-TRUE, FALSE> = IsString<T> extends true ? TRUE : IsString<T> extends false ? FALSE : TRUE | FALSE;
-//# sourceMappingURL=IfString.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfString.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EAAE,EAAE;AACL,IAAI,EACJ,KAAK,IACH,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC"}

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

@@ -1,20 +0,0 @@
-import { IfNever, IsStringLiteral } from "../../index";
-/**
- * **IfStringLiteral**
- *
- * Branch utility which returns `IF` type when `T` is a string
- * literal and `ELSE` otherwise
- */
-export type IfStringLiteral<T, IF = T, ELSE = T> = IfNever<T, ELSE, [
-    IsStringLiteral<T>
-] extends [true] ? IF : ELSE>;
-/**
- * **IfNotStringLiteral**
- *
- * Branch utility which returns `IF` type when `T` is **not** a string
- * literal and `ELSE` otherwise
- */
-export type IfNotStringLiteral<T, IF = T, ELSE = T> = IfNever<T, IF, [
-    IsStringLiteral<T>
-] extends [true] ? ELSE : IF>;
-//# sourceMappingURL=IfStringLiteral.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfStringLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfStringLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,oBAAwB;AAE3D;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CACzB,CAAC,EACD,EAAE,GAAG,CAAC,EACN,IAAI,GAAG,CAAC,IACN,OAAO,CACT,CAAC,EACD,IAAI,EACJ;IAAC,eAAe,CAAC,CAAC,CAAC;CAAC,SAAS,CAAC,IAAI,CAAC,GACjC,EAAE,GACF,IAAI,CACP,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAC5B,CAAC,EACD,EAAE,GAAG,CAAC,EACN,IAAI,GAAG,CAAC,IACN,OAAO,CACT,CAAC,EACD,EAAE,EACF;IAAC,eAAe,CAAC,CAAC,CAAC;CAAC,SAAS,CAAC,IAAI,CAAC,GAC/B,IAAI,GACJ,EAAE,CACP,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsSymbol } from "../../index";
-/**
- * **IfSymbol**`<T,IF,ELSE>`
- *
- * Type utility which converts type `T` to `IF` or `ELSE` based on whether
- * `T` is of type **Symbol**.
- */
-export type IfSymbol<T, IF, ELSE> = IsSymbol<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfSymbol.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfSymbol.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfSymbol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,12 +0,0 @@
-import { IsTrue } from "../../index";
-/**
- * **IfType**`<T,IF,ELSE>`
- *
- * Type utility which checks for literal `true` value and then switches type
- * to the `IF` or `ELSE` generic types.
- *
- * Note: the wide _boolean_ type or any non-boolean type results in `ELSE`;
- * if you are looking for different behavior consider `IfSoftTrue` instead.
- */
-export type IfTrue<T, IF = T & true, ELSE = Exclude<T, true>> = IsTrue<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfTrue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfTrue.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,oBAAwB;AAEzC;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EACD,EAAE,GAAG,CAAC,GAAG,IAAI,EACb,IAAI,GAAG,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,IACrB,MAAM,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}

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

@@ -1,11 +0,0 @@
-import { IsTruthy } from "../../index";
-/**
- * **IfTruthy**`<T,IF,ELSE,MAYBE>`
- *
- * A type utility which evaluates `T` for _[truthiness](https://frontend.turing.edu/lessons/module-1/js-truthy-falsy-expressions.html)_ and returns `IF` when true and `ELSE` if not.
- *
- * If it's not sure -- meaning it there are wide types which make design time
- * evaluation impossible -- then the MAYBE type is returned.
- */
-export type IfTruthy<T, TRUE, FALSE, MAYBE = unknown> = IsTruthy<T> extends true ? TRUE : IsTruthy<T> extends false ? FALSE : MAYBE;
-//# sourceMappingURL=IfTruthy.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfTruthy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfTruthy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,EACD,IAAI,EACJ,KAAK,EACL,KAAK,GAAG,OAAO,IACb,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAI,GACxB,IAAI,GACJ,QAAQ,CAAC,CAAC,CAAC,SAAS,KAAK,GACvB,KAAK,GACL,KAAK,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IsTuple } from "../../index";
-/**
- * **IfTuple**`<T,IF,ELSE>`
- *
- * A branching utility which returns type `IF` when `T` is a tuple
- * and `ELSE` otherwise.
- */
-export type IfTuple<T, IF, ELSE> = IsTuple<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfTuple.d.ts.map

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

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

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

@@ -1,12 +0,0 @@
-import { IfNever, IsUndefined } from "../../index";
-/**
- * **IfUndefined**`<T, IF, [ELSE]>`
- *
- * Type utility which returns `IF` type when `T` is an _undefined_
- * otherwise returns `ELSE` type.
- *
- * - if `ELSE` type is _not_ defined that the type of `T` will be
- * proxied forward
- */
-export type IfUndefined<T, IF, ELSE = T> = IfNever<T, never, IsUndefined<T> extends true ? IF : ELSE>;
-//# sourceMappingURL=IfUndefined.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfUndefined.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfUndefined.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,oBAAwB;AAEvD;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,EACD,EAAE,EACF,IAAI,GAAG,CAAC,IACN,OAAO,CACT,CAAC,EACD,KAAK,EACL,WAAW,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CACxC,CAAC"}

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

@@ -1,8 +0,0 @@
-import { IsUnion } from "../../index";
-/**
- * **IfUnion**`<T,IF,ELSE>`
- *
- * Type branching utility based on whether type `T` is a union type
- */
-export type IfUnion<T, IF, ELSE> = IsUnion<T> extends true ? IF : ELSE;
-//# sourceMappingURL=IfUnion.d.ts.map

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

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

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

@@ -1,13 +0,0 @@
-import { IsValidDotPath } from "../../index";
-/**
- * **IfValidDotPath**`<TContainer,TDotPath,IF,ELSE,[MAYBE]>`
- *
- * Branching utility which is based on whether `TDotPath` is a valid dot path
- * for the container `TContainer`.
- *
- * - you may state a `MAYBE` type -- which is mapped to when not enough information
- * exists in the design time environment and `IsValidDotPath` returns "boolean"; by default
- * this type is a union between `IF` and `ELSE`.
- */
-export type IfValidDotPath<TContainer, TDotPath, IF, ELSE, MAYBE = IF | ELSE> = IsValidDotPath<TContainer, TDotPath> extends true ? IF : IsValidDotPath<TContainer, TDotPath> extends false ? ELSE : MAYBE;
-//# sourceMappingURL=IfValidDotPath.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfValidDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfValidDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,oBAAwB;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,CACxB,UAAU,EACV,QAAQ,EACR,EAAE,EACF,IAAI,EACJ,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,cAAc,CAAC,UAAU,EAAC,QAAQ,CAAC,SAAS,IAAI,GAChD,EAAE,GACF,cAAc,CAAC,UAAU,EAAC,QAAQ,CAAC,SAAS,KAAK,GAC/C,IAAI,GACJ,KAAK,CAAC"}

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

@@ -1,32 +0,0 @@
-import { AnyObject, Concat, Container, ErrorCondition, IfFalse, IsValidKey, ToString, Tuple } from "../../index";
-type Err<TContainer extends Container, TKey extends PropertyKey> = TContainer extends Tuple ? TKey extends string | symbol ? ErrorCondition<"invalid-key-type", Concat<["An array can only have numeric keys and we found the key: '", ToString<TKey>, "'."]>, {
-    container: TContainer;
-    key: TKey;
-    library: "IfValidKey";
-}> : ErrorCondition<"key-does-not-exist", Concat<["An index of ", ToString<TKey>, " is beyond the length of the array!"]>, {
-    container: TContainer;
-    key: TKey;
-    library: "IfValidKey";
-}> : TContainer extends AnyObject ? TKey extends number ? ErrorCondition<"invalid-key-type", "", {
-    container: TContainer;
-    key: TKey;
-    library: "IfValidKey";
-}> : ErrorCondition<"key-does-not-exist", Concat<["An attempt to index an object with '", ToString<TKey>, "' is not a valid key on the object!"]>, {
-    container: TContainer;
-    key: TKey;
-    library: "IfValidKey";
-}> : never;
-/**
- * **IfValidKey**`<TContainer,TKey,[IF],[ELSE],[MAYBE]>`
- *
- * Branching utility based on whether `TKey` is a valid key for the
- * container `TContainer`.
- *
- * - `MAYBE` is by default the union of `IF` and `ELSE` and is branched to
- * if the container or key is not a literal type.
- * - `IF` type -- when not explicitly set -- will return the indexed value
- * - `ELSE` type --when not explicitly set -- will provide a reasonable set of `ErrorCondition`'s
- */
-export type IfValidKey<TContainer extends Container, TKey extends PropertyKey, IF = TKey extends keyof TContainer ? TContainer[TKey] : never, ELSE = Err<TContainer, TKey>, MAYBE = IF | ELSE> = IsValidKey<TContainer, TKey> extends true ? IF : IfFalse<IsValidKey<TContainer, TKey>, ELSE, MAYBE>;
-export {};
-//# sourceMappingURL=IfValidKey.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfValidKey.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfValidKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,oBAAwB;AAErH,KAAK,GAAG,CACN,UAAU,SAAS,SAAS,EAC5B,IAAI,SAAS,WAAW,IAE1B,UAAU,SAAS,KAAK,GAAG,IAAI,SAAS,MAAM,GAAG,MAAM,GACjD,cAAc,CACZ,kBAAkB,EAClB,MAAM,CAAC,CAAC,6DAA6D,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,EAC7F;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAC5D,GACD,cAAc,CACZ,oBAAoB,EACpB,MAAM,CAAC,CAAC,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,qCAAqC,CAAC,CAAC,EAC/E;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAC5D,GACL,UAAU,SAAS,SAAS,GAAG,IAAI,SAAS,MAAM,GAC9C,cAAc,CACZ,kBAAkB,EAClB,EAAE,EACF;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAC5D,GACD,cAAc,CACZ,oBAAoB,EACpB,MAAM,CAAC,CAAC,sCAAsC,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,qCAAqC,CAAC,CAAC,EACvG;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAC5D,GACL,KAAK,CAAC;AAER;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,CACpB,UAAU,SAAS,SAAS,EAC5B,IAAI,SAAS,WAAW,EACxB,EAAE,GAAG,IAAI,SAAS,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,EAC7D,IAAI,GAAG,GAAG,CAAC,UAAU,EAAC,IAAI,CAAC,EAC3B,KAAK,GAAG,EAAE,GAAG,IAAI,IACf,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,IAAI,GACzC,EAAE,GACF,OAAO,CACL,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,EAC5B,IAAI,EACJ,KAAK,CACN,CAAC"}

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

@@ -1,9 +0,0 @@
-import { IfLiteral } from "../../index";
-/**
- * **IfWide**`<T,TRUE,FALSE>`
- *
- * Branching utility which branches based on whether `T` is a "wide type" or not.
- */
-export type IfWide<T, //
-TRUE, FALSE = T> = IfLiteral<T, FALSE, TRUE>;
-//# sourceMappingURL=IfWide.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IfWide.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/branching/IfWide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,SAAS,EAAE,oBAAwB;AAE7C;;;;GAIG;AACH,MAAM,MAAM,MAAM,CAChB,CAAC,EAAE,EAAE;AACL,IAAI,EACJ,KAAK,GAAG,CAAC,IACP,SAAS,CACX,CAAC,EACD,KAAK,EACL,IAAI,CACL,CAAC"}

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

@@ -1,13 +0,0 @@
-import { IfNever, SomeEqual, IfOr, IsWideType } from "../../index";
-/**
- * **Includes**`<TSource, TValue>`
- *
- * Type utility which returns `true` or `false` based on whether `TValue` is found
- * in `TSource`. Where `TSource` can be a string literal or an array of string literals.
- *
- * **Note:** if the source is a _wide_ type (aka, `string` or `string[]`) then there is
- * no way to know at design-time whether the value includes `TValue` and so it will return
- * a type of `boolean`.
- */
-export type Includes<TSource extends string | readonly string[], TValue extends string> = IfNever<TValue, false, IfOr<[IsWideType<TValue>, IsWideType<TSource>], boolean, TSource extends string[] ? SomeEqual<TValue, TSource> : TSource extends `${string}${TValue}${string}` ? true : false>>;
-//# sourceMappingURL=Includes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Includes.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/Includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,OAAO,EAAE,SAAS,EAAG,IAAI,EAAE,UAAU,EAAE,oBAAwB;AAGzE;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,CAClB,OAAO,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,EAC1C,MAAM,SAAS,MAAM,IACnB,OAAO,CAAC,MAAM,EAAE,KAAK,EACvB,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EACvD,OAAO,SAAS,MAAM,EAAE,GACpB,SAAS,CAAC,MAAM,EAAC,OAAO,CAAC,GACzB,OAAO,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAC1C,IAAI,GACL,KAAK,CACZ,CAAC,CAAC"}

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

@@ -1,8 +0,0 @@
-import { IfStringLiteral, Length } from "../../index";
-/**
- * **IsChar**`<T>`
- *
- * Boolean operator which returns true/false/boolean based on whether `T` is a
- */
-export type IsChar<T> = T extends string ? Length<T> extends 1 ? true : IfStringLiteral<T, false, boolean> : false;
-//# sourceMappingURL=IsChar.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsChar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsChar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,eAAe,EAAE,MAAM,EAAE,oBAAwB;AAE3D;;;;GAIG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GACpC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GACjB,IAAI,GACJ,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,GACpC,KAAK,CAAC"}

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

@@ -1,32 +0,0 @@
-import { ErrorCondition, IfNever, Includes } from "../../index";
-export interface IsErrorOptions {
-    /** evaluate the `never` type as an error in this utility */
-    neverAsError?: boolean;
-    /** evaluate JS's `Error` constructor as an error in this utility */
-    errorAsError?: boolean;
-    /** only identify `ErrorConditions<TKind>` as errors */
-    kind?: string;
-    /**  */
-    msgIncludes?: string;
-}
-type Process<T extends ErrorCondition, O extends IsErrorOptions> = O["msgIncludes"] extends string ? Includes<T["message"], O["msgIncludes"]> extends true ? true : false : true;
-/**
- * **IsError**`<T, [IsErrorOptions]>`
- *
- * A boolean utility which detects whether T represents an error condition.
- *
- * - the primary criteria is whether `T` extends `ErrorCondition`
- * - Error Scope
- *    - the option `{ neverAsError: true }` will make the type `never`
- * evaluate to `true`; it evaluates to `false` by default
- *    - the option `errorAsError` set to true does the same thing for
- * Javascript's `Error` type.
- * - Filtering
- *    - the `kind` option property will to filter down the _kind_ property
- * of the `ErrorCondition`'s you looking for
- *    - the `msgIncludes` property filters down errors to those which _include_ the
- * text specified as part of the error message. Useful for type tests.
- */
-export type IsError<T, O extends IsErrorOptions = IsErrorOptions> = IfNever<T, O["neverAsError"] extends true ? true : false, T extends Error ? O["errorAsError"] extends true ? true : false : O["kind"] extends string ? T extends ErrorCondition<O["kind"]> ? Process<T, O> : false : T extends ErrorCondition ? Process<T, O> : false>;
-export {};
-//# sourceMappingURL=IsError.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsError.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAEpE,MAAM,WAAW,cAAc;IAC7B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,oEAAoE;IACpE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO;IACP,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,KAAK,OAAO,CACV,CAAC,SAAS,cAAc,EACxB,CAAC,SAAS,cAAc,IACtB,CAAC,CAAC,aAAa,CAAC,SAAS,MAAM,GACjC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,SAAS,IAAI,GACnD,IAAI,GACJ,KAAK,GACP,IAAI,CAAC;AAEP;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,SAAS,cAAc,GAAG,cAAc,IACvC,OAAO,CACT,CAAC,EACD,CAAC,CAAC,cAAc,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,EAE7C,CAAC,SAAS,KAAK,GACX,CAAC,CAAC,cAAc,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,GAC7C,CAAC,CAAC,MAAM,CAAC,SAAS,MAAM,GACtB,CAAC,SAAS,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAC,CAAC,CAAC,GAAG,KAAK,GAC1D,CAAC,SAAS,cAAc,GAAG,OAAO,CAAC,CAAC,EAAC,CAAC,CAAC,GAAG,KAAK,CAEtD,CAAC"}

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

@@ -1,10 +0,0 @@
-import { AnyObject, Container, IfEqual, Keys } from "../../index";
-/**
- * **IsIndexable**`<T>`
- *
- * Boolean operator which returns whether the true when
- * T is a container and has _at least_ **one** key known at design
- * time.
- */
-export type IsIndexable<T> = T extends Container ? T extends unknown[] ? IfEqual<T["length"], number, false, IfEqual<T["length"], 0, false, true>> : T extends AnyObject ? IfEqual<Keys<T>, number, false, true> : false : false;
-//# sourceMappingURL=IsIndexable.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"IsIndexable.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsIndexable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,oBAAwB;AAEtE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IACzB,CAAC,SAAS,SAAS,GACf,CAAC,SAAS,OAAO,EAAE,GACjB,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM,EACnB,KAAK,EACL,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CACrC,GACD,CAAC,SAAS,SAAS,GACjB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,GACrC,KAAK,GACT,KAAK,CAAC"}

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

@@ -1,14 +0,0 @@
-import { IfFalse, IfTrue, IsBoolean } from "../../index";
-/**
- * **IsMaybeTrue**`<T>`
- *
- * Type utility which checks for the narrow type of `true` but
- * only converts what it knows at design time. Valid return
- * types are:
- *
- * - `true` - known to be of `true` type
- * - `false` - known to be of `false` type (aka, "false" or non-boolean)
- * - `boolean` - can't determine true/false at design time
- */
-export type IsMaybeTrue<T> = IsBoolean<T> extends true ? IfTrue<T, true, IfFalse<T, false, boolean>> : false;
-//# sourceMappingURL=IsMaybeTrue.d.ts.map