inferred-types 0.42.1 → 0.43.1

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

@@ -1,4 +1,5 @@
-import { HasCharacters, IfNever, IfStringLiteral } from "../../index";
+import { HasCharacters, IsNever, StartsWith, IsStringLiteral, EndsWith, Contains, IsEqual } from "../../index";
+type CheckForInvalid<T extends string> = HasCharacters<T, ["/", "*", "!", "&", "$", "\\"]> extends true ? true : StartsWith<T, "."> extends true ? true : EndsWith<T, "."> extends true ? true : Contains<T, ".."> extends true ? true : false;
 /**
  * **IsDotPath**`<T>`
  *
@@ -10,9 +11,10 @@ import { HasCharacters, IfNever, IfStringLiteral } from "../../index";
  * - `boolean` - a wide string type
  * - `true` - a string literal value where `DotPath<T>` does not resolve to _never_.
  *
- * Note: this utility does not validate that `T` is a _valid_ dot path for any indexable
+ * Note: this utility does not validate that `T` is a _valid_ dot path for a particular
  * container; only that it is a valid looking dotpath. If you want this validation use
  * `IsValidDotPath<TContainer, TKey>` instead.
  */
-export type IsDotPath<T> = IfNever<T, false, T extends string ? IfStringLiteral<T, HasCharacters<T, ["/", "*", "!", "&", "$", "\\"]> extends true ? false : true, boolean> : false>;
+export type IsDotPath<T, TIf = true, TElse = false, TMaybe = TIf | TElse> = [IsNever<T>] extends [true] ? false : T extends string ? [IsEqual<T, "">] extends [true] ? true : IsStringLiteral<T> extends true ? CheckForInvalid<T> extends true ? TElse : TIf : TMaybe : false;
+export {};
 //# sourceMappingURL=IsDotPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,oBAAwB;AAE3E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,OAAO,CAChC,CAAC,EACD,KAAK,EACL,CAAC,SAAS,MAAM,GACZ,eAAe,CACb,CAAC,EACD,aAAa,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,SAAS,IAAI,GAAG,KAAK,GAAG,IAAI,EAC7E,OAAO,CACR,GACD,KAAK,CACV,CAAC"}
+{"version":3,"file":"IsDotPath.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsDotPath.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,OAAO,EACP,UAAU,EACV,eAAe,EACf,QAAQ,EACR,QAAQ,EACR,OAAO,EACR,oBAAwB;AAEzB,KAAK,eAAe,CAClB,CAAC,SAAS,MAAM,IACd,aAAa,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,SAAS,IAAI,GAChE,IAAI,GACJ,UAAU,CAAC,CAAC,EAAC,GAAG,CAAC,SAAS,IAAI,GAC9B,IAAI,GACJ,QAAQ,CAAC,CAAC,EAAC,GAAG,CAAC,SAAS,IAAI,GAC5B,IAAI,GACJ,QAAQ,CAAC,CAAC,EAAC,IAAI,CAAC,SAAS,IAAI,GAC7B,IAAI,GACJ,KAAK,CAAC;AAER;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,EACD,GAAG,GAAG,IAAI,EACV,KAAK,GAAG,KAAK,EACb,MAAM,GAAG,GAAG,GAAG,KAAK,IAClB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3B,KAAK,GACL,CAAC,SAAS,MAAM,GACd,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAE,SAAS,CAAC,IAAI,CAAC,GAC9B,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,KAAK,GACL,GAAG,GACL,MAAM,GACd,KAAK,CAAA"}

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

@@ -1,9 +1,10 @@
-import type { AnyObject, IfLength, Keys } from "../../index";
+import type { AsRecord, Dictionary, IsNumericLiteral, Keys } from "../../index";
 /**
  * **IsEmptyObject**`<T>`
  *
  * Boolean type util which detects whether `T` _is_ an object
  * but _has no properties_.
  */
-export type IsEmptyObject<T> = T extends AnyObject ? IfLength<Keys<T>, 0, true, false> : false;
+export type IsEmptyObject<T> = T extends Dictionary ? Keys<AsRecord<T>>["length"] extends 0 ? true : false : false;
+export type IsNonEmptyObject<T> = T extends Dictionary ? Keys<AsRecord<T>>["length"] extends 0 ? false : IsNumericLiteral<Keys<AsRecord<T>>["length"]> extends true ? true : false : false;
 //# sourceMappingURL=IsEmptyObject.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsEmptyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsEmptyObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAC,oBAAwB;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAC9C,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,GACjC,KAAK,CAAC"}
+{"version":3,"file":"IsEmptyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsEmptyObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAG,UAAU,EAAG,gBAAgB,EAAG,IAAI,EAAC,oBAAwB;AAErF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,GAC/C,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,KAAK,GACpD,KAAK,CAAC;AAEV,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,GAClD,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GACnC,KAAK,GACL,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,SAAS,IAAI,GACxD,IAAI,GACJ,KAAK,GACT,KAAK,CAAC"}

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

@@ -3,5 +3,5 @@
  *
  * Type utility which tests whether two types -- `X` and `Y` -- are exactly the same type
  */
-export type IsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type IsEqual<X, Y, TRUE = true, FALSE = false> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? TRUE : FALSE;
 //# sourceMappingURL=IsEqual.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsEqual.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GAC3F,IAAI,GACJ,KAAK,CAAC"}
+{"version":3,"file":"IsEqual.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsEqual.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,OAAO,CACjB,CAAC,EACD,CAAC,EACD,IAAI,GAAG,IAAI,EACX,KAAK,GAAG,KAAK,IACX,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,GACnE,IAAI,GACJ,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import type { ErrorCondition, IfNull } from "../../index";
+import type { ErrorCondition } from "../../index";
 /**
  * **IsErrorCondition**`<TEval,[TKind]>`
  *
@@ -7,5 +7,5 @@ import type { ErrorCondition, IfNull } from "../../index";
  * - If you want to isolate to only a particular _kind_ of error you may
  * also use the optional `TKind` generic.
  */
-export type IsErrorCondition<TEval, TKind = null> = TEval extends ErrorCondition<any> ? IfNull<TKind, true, TKind extends TEval["kind"] ? true : false> : false;
+export type IsErrorCondition<TEval, TKind extends string | null = null> = TEval extends ErrorCondition ? TKind extends string ? TEval extends ErrorCondition<TKind> ? true : false : true : false;
 //# sourceMappingURL=IsErrorCondition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsErrorCondition.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsErrorCondition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAG,cAAc,EAAE,MAAM,EAAE,oBAAwB;AAE/D;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,IAAI,KAAK,SAAS,cAAc,CAAC,GAAG,CAAC,GACjF,MAAM,CACJ,KAAK,EACL,IAAI,EACJ,KAAK,SAAS,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,KAAK,CAC3C,GACD,KAAK,CAAC"}
+{"version":3,"file":"IsErrorCondition.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsErrorCondition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAwB;AAEtD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,CAC1B,KAAK,EACL,KAAK,SAAS,MAAM,GAAG,IAAI,GAAG,IAAI,IAChC,KAAK,SAAS,cAAc,GAC5B,KAAK,SAAS,MAAM,GAClB,KAAK,SAAS,cAAc,CAAC,KAAK,CAAC,GACjC,IAAI,GAAG,KAAK,GACd,IAAI,GACN,KAAK,CAAC"}

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

@@ -1,3 +1,8 @@
-import { IfExtendsSome } from "../../index";
-export type IsFalsy<T> = IfExtendsSome<T, ["", false, null, undefined, 0, -0, typeof Number.NaN], true, false>;
+import { If, ExtendsSome } from "../../index";
+/**
+ * **IsFalsy**`<T>`
+ *
+ * Boolean operator which tests whether `T` is _falsy_.
+ */
+export type IsFalsy<T> = If<ExtendsSome<T, ["", false, null, undefined, 0, -0, typeof Number.NaN]>, true, false>;
 //# sourceMappingURL=IsFalsy.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsFalsy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFalsy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAwB;AAEhD,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,aAAa,CACpC,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,MAAM,CAAC,GAAG,CAAC,EACzD,IAAI,EACJ,KAAK,CACN,CAAC"}
+{"version":3,"file":"IsFalsy.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFalsy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,WAAW,EAAE,oBAAwB;AAElD;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,EAAE,CACzB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,EACtE,IAAI,EACJ,KAAK,CACN,CAAC"}

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

@@ -0,0 +1,13 @@
+import { AsString, HasCharacters, IsNever, IsStringLiteral, NumberLike } from "../..";
+/**
+ * **IsFloat**`<T>`
+ *
+ * Boolean operator which tests whether `T` is a **float** representation of
+ * a `NumberLike` type `T`.
+ *
+ * **Warning:** when using numeric values like `1.0` the `.0` portion is lost before
+ * making the comparison so it is not possible to mark this as a float value.
+ * However, the string literal version of `"1.0"` **is** marked as a float.
+ */
+export type IsFloat<T> = [IsNever<T>] extends [true] ? false : [T] extends [NumberLike] ? [IsStringLiteral<AsString<T>>] extends [true] ? [HasCharacters<AsString<T>, ".">] extends [true] ? true : false : boolean : false;
+//# sourceMappingURL=IsFloat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsFloat.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFloat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAGtF;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAClD,KAAK,GACL,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GACtB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC9C,IAAI,GACJ,KAAK,GACT,OAAO,GACT,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import type { AnyObject, AnyFunction, IsEmptyObject, IfEqual, IfAnd, DoesExtend } from "../../index";
+import type { AnyObject, AnyFunction, IsEmptyObject, IsEqual, And, DoesExtend, If } from "../../index";
 /**
  * **IsFnWithParams**`<TFn, [TParamMatch]>`
  *
@@ -8,8 +8,8 @@ import type { AnyObject, AnyFunction, IsEmptyObject, IfEqual, IfAnd, DoesExtend
  * - the optional `TParamMatch` will ensure that this generic _extends_
  * the params included in the function.
  */
-export type IsFnWithParams<TFn, TParamMatch extends AnyObject | undefined = undefined> = TFn extends AnyFunction ? IsEmptyObject<TFn> extends true ? false : IfAnd<[
+export type IsFnWithParams<TFn, TParamMatch extends AnyObject | undefined = undefined> = TFn extends AnyFunction ? IsEmptyObject<TFn> extends true ? false : If<And<[
     DoesExtend<TFn, TParamMatch>,
     DoesExtend<TParamMatch, AnyObject>
-], true, IfEqual<TParamMatch, undefined, true, false>> : false;
+]>, true, If<IsEqual<TParamMatch, undefined>, true, false>> : false;
 //# sourceMappingURL=IsFnWithParams.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsFnWithParams.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFnWithParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAG,aAAa,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,oBAAwB;AAE1G;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CACxB,GAAG,EACH,WAAW,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,IACnD,GAAG,SAAS,WAAW,GACrB,aAAa,CAAC,GAAG,CAAC,SAAS,IAAI,GAC3B,KAAK,GAEL,KAAK,CACH;IAEE,UAAU,CAAC,GAAG,EAAE,WAAW,CAAC;IAE5B,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC;CACnC,EACD,IAAI,EACJ,OAAO,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,CAC/C,GACH,KAAK,CAAC"}
+{"version":3,"file":"IsFnWithParams.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFnWithParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,aAAa,EACb,OAAO,EACP,GAAG,EACH,UAAU,EACV,EAAE,EACH,oBAAwB;AAEzB;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CACxB,GAAG,EACH,WAAW,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,IACnD,GAAG,SAAS,WAAW,GACrB,aAAa,CAAC,GAAG,CAAC,SAAS,IAAI,GAC3B,KAAK,GAEL,EAAE,CACA,GAAG,CAAC;IAEF,UAAU,CAAC,GAAG,EAAE,WAAW,CAAC;IAE5B,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC;CACnC,CAAC,EACF,IAAI,EACJ,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CACnD,GACH,KAAK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"IsFunction.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAwB;AAGnD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"IsFunction.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsFunction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAG,WAAW,EAAE,oBAAwB;AAGpD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAAG,IAAI,GAAG,KAAK,CAAC"}

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

@@ -1,9 +1,13 @@
-import { GreaterThan, ToNumber } from "../../index";
+import { AsNumber } from "../../index";
+type Calc<A extends number, B extends number, Count extends 1[] = []> = Count["length"] extends A ? false : Count["length"] extends B ? true : Calc<A, B, [...Count, 1]>;
 /**
  * **IsGreaterThan**`<A,B>`
  *
  * Boolean type operator which determines whether `A`
  * is _greater than_ `B`.
+ *
+ * **Note:** does not take negative numbers into account
  */
-export type IsGreaterThan<A extends number | `${number}`, B extends number | `${number}`> = GreaterThan<A extends number ? A : ToNumber<A>, B extends number ? B : ToNumber<B>> extends true ? true : false;
+export type IsGreaterThan<A extends number | `${number}`, B extends number | `${number}`> = Calc<AsNumber<A>, AsNumber<B>>;
+export {};
 //# sourceMappingURL=IsGreaterThan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsGreaterThan.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,QAAQ,EAAE,oBAAwB;AAEzD;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,EAC9B,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,IAC5B,WAAW,CACb,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EAClC,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CACnC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"IsGreaterThan.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,oBAAwB;AAE3C,KAAK,IAAI,CACP,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,EAChB,KAAK,SAAS,CAAC,EAAE,GAAG,EAAE,IAExB,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,GACrB,KAAK,GACL,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,GACvB,IAAI,GACJ,IAAI,CAAC,CAAC,EAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,CACvB,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,EAC9B,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,EAAE,IAC5B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,9 @@
+import { HasOtherCharacters, Hexadecimal, HexadecimalChar, IsStringLiteral } from "../../index";
+/**
+ * **IsHexadecimal**`<T>`
+ *
+ * Ensures that `T` is a valid hexadecimal and converts to **never**
+ * otherwise.
+ */
+export type IsHexadecimal<T> = T extends string ? IsStringLiteral<T> extends true ? T extends Hexadecimal ? HasOtherCharacters<T, HexadecimalChar | "#"> extends true ? false : true : false : boolean : boolean;
+//# sourceMappingURL=IsHexadecimal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsHexadecimal.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsHexadecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAAE,oBAAuB;AAEnG;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC7C,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,CAAC,SAAS,WAAW,GACnB,kBAAkB,CAAC,CAAC,EAAE,eAAe,GAAG,GAAG,CAAC,SAAS,IAAI,GACvD,KAAK,GACL,IAAI,GACR,KAAK,GACL,OAAO,GACT,OAAO,CAAC"}

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

@@ -0,0 +1,9 @@
+import { AsString, HasCharacters, IsNever, IsStringLiteral, NumberLike } from "../..";
+/**
+ * **IsInteger**`<T>`
+ *
+ * Boolean operator which tests whether `T` is a **integer** representation of
+ * a `NumberLike` type `T`.
+ */
+export type IsInteger<T> = [IsNever<T>] extends [true] ? false : [T] extends [NumberLike] ? [IsStringLiteral<AsString<T>>] extends [true] ? [HasCharacters<AsString<T>, ".">] extends [true] ? false : true : boolean : false;
+//# sourceMappingURL=IsInteger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsInteger.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsInteger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAGtF;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACpD,KAAK,GACL,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GACtB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC9C,KAAK,GACL,IAAI,GACR,OAAO,GACT,KAAK,CAAC"}

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

@@ -0,0 +1,10 @@
+import { Container, Contains, IsNever, Dictionary, Keys } from "../../index";
+type Process<T extends Container> = T extends Generator ? true : T extends Map<any, any> ? true : T extends WeakMap<any, any> ? true : T extends Set<any> ? true : T extends readonly any[] ? true : T extends Dictionary ? Contains<Keys<T>, Iterator<T>> extends true ? true : false : false;
+/**
+ * **IsIterable**`<T>`
+ *
+ * Boolean operator which tests whether `T` is iterable.
+ */
+export type IsIterable<T, TNever = never> = IsNever<T> extends true ? TNever : T extends Container ? Process<T> : false;
+export {};
+//# sourceMappingURL=IsIterable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsIterable.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsIterable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,oBAAwB;AAEjF,KAAK,OAAO,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,SAAS,SAAS,GACnD,IAAI,GACJ,CAAC,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,GACvB,IAAI,GACJ,CAAC,SAAS,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GAC3B,IAAI,GACJ,CAAC,SAAS,GAAG,CAAC,GAAG,CAAC,GAClB,IAAI,GACJ,CAAC,SAAS,SAAS,GAAG,EAAE,GACxB,IAAI,GACJ,CAAC,SAAS,UAAU,GACpB,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACzC,IAAI,GACJ,KAAK,GACP,KAAK,CAAC;AAGV;;;;GAIG;AACH,MAAM,MAAM,UAAU,CACpB,CAAC,EACD,MAAM,GAAG,KAAK,IACZ,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACzB,MAAM,GACN,CAAC,SAAS,SAAS,GACjB,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAC"}

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

@@ -1,35 +1,22 @@
-import type { IsBooleanLiteral, IsNumericLiteral, IsObjectLiteral, IsStringLiteral, IsTuple, IfNever } from "../../index";
+import type { IsStringLiteral, IsNumericLiteral, IsTuple, IsBooleanLiteral, IsObjectLiteral, IfEqual, IsUnion } from "../../index";
+type Validations<T> = IsStringLiteral<T> extends true ? true : IsNumericLiteral<T> extends true ? true : IsTuple<T> extends true ? true : IsBooleanLiteral<T> extends true ? true : IsObjectLiteral<T> extends true ? true : false;
 /**
  * **IsLiteral**`<T>`
  *
- * Boolean type literal which tests whether `T` is a _literal_ value or not.
+ * Boolean utility which returns `true` when `T` is:
  *
- * - ensures that strings, numbers, and boolean values are literal/narrow types
- * - ensures that arrays (including readonly arrays) have a known set of values (length known at design time); some of the known values in the tuple _may_ be wide types
- * - ensures that objects have a known set of keys (including no keys)
- * - symbols, and null values will return **true** as they are always unique
- * - _undefined_ will always return **false**
- * - a **literal array** is one where the discrete elements are known; some of the elements _may_ be wide types
+ * - string literal
+ * - numeric literal
+ * - boolean literal
+ * - object literal
+ * - or a tuple literal
  *
- */
-export type IsLiteral<T> = IfNever<T, false, IsStringLiteral<T> extends true ? true : IsBooleanLiteral<T> extends true ? true : IsNumericLiteral<T> extends true ? true : IsTuple<T> extends true ? true : IsObjectLiteral<T> extends true ? true : false>;
-/**
- * **IsOptionalLiteral**
- *
- * Type utility which returns true/false if the value passed -- a form of a
- * string, number, or boolean -- is a _literal_ value of that type (true) or
- * the more generic wide type (false).
- *
- * This type also strips off _undefined_ from any possible union type to evaluate
- * to `true` even when a literal value is in union with _undefined_. If you don't
- * want to test for the union with _undefined_ use the `IsOptional` utility instead.
- */
-export type IsOptionalLiteral<T> = [Exclude<T, undefined>] extends [string] ? IsStringLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [boolean] ? IsBooleanLiteral<Exclude<T, undefined>> : [Exclude<T, undefined>] extends [number] ? IsNumericLiteral<Exclude<T, undefined>> : false;
-/**
- * **IfOptionalLiteral**
+ * Note: when `T` is a _union type_, even if there are literal types
+ * in the union, this will return `false`.
  *
- * Branch type utility with return `IF` when `T` is a _literal_ value (with possibly
- * the inclusion of _undefined_); otherwise returns the type `ELSE`
+ * **Related:** `IsUnion`, `IsWideUnion`, `IsLiteralUnion`
  */
-export type IfOptionalLiteral<T, IF, ELSE> = IsOptionalLiteral<T> extends true ? IF : ELSE;
+export type IsLiteral<T> = [IsUnion<T>] extends [true] ? false : Validations<T>;
+export type IsOptionalLiteral<T> = IfEqual<T, undefined, true, IsLiteral<T>>;
+export {};
 //# sourceMappingURL=IsLiteral.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,eAAe,EAChB,OAAO,EACP,OAAO,EAAC,oBAAwB;AAKjC;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,OAAO,CAChC,CAAC,EACD,KAAK,EACL,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9B,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9B,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC7B,IAAI,GACJ,KAAK,CAClB,CAAC;AAGF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACvE,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GACtC,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GACzC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GACvC,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GACxC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,GACvC,KAAK,CAAC;AAIV;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAC3B,CAAC,EACD,EAAE,EACF,IAAI,IACF,iBAAiB,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC"}
+{"version":3,"file":"IsLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsLiteral.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,eAAe,EACf,gBAAgB,EAChB,OAAO,EACP,gBAAgB,EAChB,eAAe,EACf,OAAO,EACP,OAAO,EACP,oBAAwB;AAEzB,KAAK,WAAW,CAAC,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GACnD,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACvB,IAAI,GACJ,gBAAgB,CAAC,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/B,IAAI,GACJ,KAAK,CAAC;AAER;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACpD,KAAK,GACL,WAAW,CAAC,CAAC,CAAC,CAAA;AAMhB,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA"}

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

@@ -0,0 +1,16 @@
+import { AnyFunction } from "../..";
+import { IsEqual } from "./IsEqual";
+type RegularFn<Fn> = Fn extends ((...args: any[]) => any) ? (...args: Parameters<Fn>) => ReturnType<Fn> : false;
+/**
+ * **IsLiteralFn**`<TFn>`
+ *
+ * A boolean operator which checks that `TFn`:
+ *
+ * - is a function
+ * - does not use generics to narrow input parameters
+ *
+ * **Related:** `LiteralFn`, `IsNarrowFn`
+ */
+export type IsLiteralFn<TFn> = TFn extends AnyFunction ? IsEqual<RegularFn<TFn>, TFn> : false;
+export {};
+//# sourceMappingURL=IsLiteralFn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsLiteralFn.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsLiteralFn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,KAAK,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,GACvD,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,UAAU,CAAC,EAAE,CAAC,GAC3C,KAAK,CAAC;AAGR;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,IAAI,GAAG,SAAS,WAAW,GACpD,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,EAAC,GAAG,CAAC,GAC3B,KAAK,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsLiteralUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsLiteralUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,OAAO,EAAE,cAAc,EAAG,YAAY,EAAE,MAAM,OAAO,CAAC;AAGhE,KAAK,OAAO,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1D,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GACzE,IAAI,GACJ,KAAK,GACP,KAAK,CAAC;AAER;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC9B,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAC"}

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

@@ -0,0 +1,12 @@
+import { AnyFunction, Not, IsEqual, LiteralFn } from "../../index";
+/**
+ * **IsNarrowingFn**`<TFn>`
+ *
+ * A boolean operator which checks whether `TFn` uses generics
+ * to narrow the input parameters. This is in contrast to a function
+ * which takes literal types rather than _extending_ them.
+ *
+ * **Related:** `NarrowingFn`, `IsLiteralFn`
+ */
+export type IsNarrowingFn<TFn> = TFn extends AnyFunction ? Not<IsEqual<LiteralFn<TFn>, TFn>> : false;
+//# sourceMappingURL=IsNarrowingFn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsNarrowingFn.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNarrowingFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,oBAAwB;AAKvE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,GAAG,IAAI,GAAG,SAAS,WAAW,GACtD,GAAG,CAAC,OAAO,CACT,SAAS,CAAC,GAAG,CAAC,EAAC,GAAG,CACnB,CAAC,GACF,KAAK,CAAC"}

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

@@ -1,4 +1,5 @@
-import { IfLiteral, IfNegativeNumber, IfNever, NumberLike } from "../../index";
+import { AsString, IsStringLiteral, IsWideType, NumberLike, StartsWith } from "../../index";
+type Process<T extends `${number}`> = [IsStringLiteral<T>] extends [true] ? T extends `${number}` ? [StartsWith<T, "-">] extends [true] ? true : false : false : boolean;
 /**
  * **IsNegativeNumber**`<T>`
  *
@@ -6,5 +7,6 @@ import { IfLiteral, IfNegativeNumber, IfNever, NumberLike } from "../../index";
  * negative value. This includes string literal representations of
  * a number.
  */
-export type IsNegativeNumber<T> = IfNever<T, false, IfLiteral<T, T extends NumberLike ? IfNegativeNumber<T, true, false> : false, boolean>>;
+export type IsNegativeNumber<T extends NumberLike> = IsWideType<T> extends true ? boolean : NumberLike extends T ? boolean : T extends number ? Process<AsString<T>> : T extends string ? Process<T> : never;
+export {};
 //# sourceMappingURL=IsNegativeNumber.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsNegativeNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNegativeNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,oBAAwB;AAEnF;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,OAAO,CACvC,CAAC,EACD,KAAK,EACL,SAAS,CACP,CAAC,EACD,CAAC,SAAS,UAAU,GAChB,gBAAgB,CAAC,CAAC,EAAC,IAAI,EAAC,KAAK,CAAC,GAC9B,KAAK,EACT,OAAO,CACR,CACF,CAAC"}
+{"version":3,"file":"IsNegativeNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNegativeNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,eAAe,EACf,UAAU,EACV,UAAU,EACV,UAAU,EACX,oBAAwB;AAEzB,KAAK,OAAO,CACV,CAAC,SAAS,GAAG,MAAM,EAAE,IACnB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACrC,CAAC,SAAS,GAAG,MAAM,EAAE,GACnB,CAAC,UAAU,CAAC,CAAC,EAAC,GAAG,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAChC,IAAI,GACJ,KAAK,GACT,KAAK,GACL,OAAO,CAAC;AAEV;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,UAAU,IAClB,UAAU,CAAC,CAAC,CAAC,SAAS,IAAI,GAC5B,OAAO,GACP,UAAU,SAAS,CAAC,GACpB,OAAO,GACP,CAAC,SAAS,MAAM,GAChB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GACpB,CAAC,SAAS,MAAM,GACd,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAA"}

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

@@ -0,0 +1,13 @@
+import { If, IsUnion, RetainLiterals, UnionToTuple } from "../..";
+type Process<T> = UnionToTuple<T> extends readonly unknown[] ? RetainLiterals<UnionToTuple<T>>["length"] extends UnionToTuple<T>["length"] ? false : true : never;
+/**
+ * **IsNonLiteralUnion**`<T>`
+ *
+ * Boolean utility which checks whether `T` is both a _union type_
+ * and that none of it's elements are considered _literal types_.
+ *
+ * **Related:** `IsLiteralUnion`, `IsWideUnion`
+ */
+export type IsNonLiteralUnion<T> = If<IsUnion<T>, Process<T>, false>;
+export {};
+//# sourceMappingURL=IsNonLiteralUnion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsNonLiteralUnion.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNonLiteralUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,EAAE,EAAE,OAAO,EAAE,cAAc,EAAG,YAAY,EAAE,MAAM,OAAO,CAAC;AAGpE,KAAK,OAAO,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1D,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GACzE,KAAK,GACL,IAAI,GACN,KAAK,CAAC;AAER;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,CAC3B,CAAC,IAAI,EAAE,CACP,OAAO,CAAC,CAAC,CAAC,EACV,OAAO,CAAC,CAAC,CAAC,EACV,KAAK,CACN,CAAA"}

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

@@ -0,0 +1,9 @@
+import { Nothing } from "../..";
+/**
+ * **IsNothing**`<T>`
+ *
+ * Boolean operator which tests whether `T` is _nothing_ (aka.,
+ * `null` or `undefined`).
+ */
+export type IsNothing<T> = [T] extends [Nothing] ? true : false;
+//# sourceMappingURL=IsNothing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsNothing.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNothing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GAC9C,IAAI,GACJ,KAAK,CAAC"}

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

@@ -1,8 +1,12 @@
+import { IsUnion } from "./IsUnion";
 /**
  * **IsNull**`<T>`
  *
  * Type utility which returns a boolean flag based on whether the given
  * type is **null**.
+ *
+ * Note: if `T` is a union type and one of the elements of the union
+ * is `null` then this will return `boolean`.
  */
-export type IsNull<T> = T extends null ? true : false;
+export type IsNull<T> = IsUnion<T> extends true ? [null] extends [T] ? boolean : false : [T] extends [null] ? true : false;
 //# sourceMappingURL=IsNull.d.ts.map

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

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

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

@@ -1,7 +1,8 @@
+import { IsUnion } from "./IsUnion";
 /**
  * **IsNumber**`<T>`
  *
  * Boolean type utility testing whether `T` is a numeric type.
  */
-export type IsNumber<T> = T extends number ? true : false;
+export type IsNumber<T> = IsUnion<T> extends true ? [number] extends [T] ? boolean : false : [T] extends [number] ? true : false;
 //# sourceMappingURL=IsNumber.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNumber.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"IsNumber.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;GAIG;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/IsObject.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction, Mutable, Or, IfExtends } from "../../index";
+import { AnyFunction, Mutable, Or, If, Extends } from "../../index";
 /**
  * **IsObject**
  *
@@ -6,8 +6,8 @@ import { AnyFunction, Mutable, Or, IfExtends } from "../../index";
  * (aka, it extends `Record<string, any>` or a readonly equivalent)
  */
 export type IsObject<T> = Or<[
-    IfExtends<T, Record<string | symbol, unknown>, true, false>,
-    IfExtends<Mutable<T>, Record<string | symbol, unknown>, true, false>,
-    IfExtends<T, object, true, false>
+    If<Extends<T, Record<string | symbol, unknown>>, true, false>,
+    If<Extends<Mutable<T>, Record<string | symbol, unknown>>, true, false>,
+    If<Extends<T, object>, true, false>
 ]> extends true ? T extends AnyFunction ? false : Mutable<T> extends unknown[] ? false : true : false;
 //# sourceMappingURL=IsObject.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,OAAO,EAAG,EAAE,EAAE,SAAS,EAAE,oBAAwB;AAExE;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3B,SAAS,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;IACxD,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC;IAChE,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC;CAClC,CAAC,SAAS,IAAI,GAEb,CAAC,SAAS,WAAW,GAEnB,KAAK,GACL,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,EAAE,GAG5B,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}
+{"version":3,"file":"IsObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAG,OAAO,EAAG,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,oBAAwB;AAE1E;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3B,EAAE,CAAC,OAAO,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;IAC1D,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAC,MAAM,CAAC,MAAM,GAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAC,IAAI,EAAE,KAAK,CAAC;IAClE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;CACpC,CAAC,SAAS,IAAI,GAEb,CAAC,SAAS,WAAW,GAEnB,KAAK,GACL,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,EAAE,GAG5B,KAAK,GACL,IAAI,GACN,KAAK,CAAC"}

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

@@ -1,11 +1,14 @@
-import { AnyObject, RemoveIndexKeys, EmptyObject, IsEqual, Keys, IndexableObject, IfNotEqual } from "../../index";
+import { Dictionary, UnionToTuple, RemoveIndexKeys, ExplicitlyEmptyObject, IsEqual, IsNever } from "../../index";
+type _Keys<T extends Dictionary> = UnionToTuple<keyof RemoveIndexKeys<T>>;
+type CheckIt<T extends Dictionary> = IsNever<keyof T> extends true ? false : IsEqual<_Keys<T>, []> extends true ? false : true;
 /**
  * **IsObjectLiteral**`<T>`
  *
  * Tests whether an object is a literal. An object literal is any of the following:
  *
- * - an `EmptyObject`
- * - an `Indexable` object with at least one explicit key defined
+ * - any KV-like type which has an **explicit** number of keys
+ * - if `Keys<T>["length"]` translates to `number` than this is **not** a literal.
  */
-export type IsObjectLiteral<T> = T extends AnyObject ? IsEqual<T, EmptyObject> extends true ? true : RemoveIndexKeys<T> extends IndexableObject ? IfNotEqual<Keys<RemoveIndexKeys<T>>, readonly [], true, false> : false : false;
+export type IsObjectLiteral<T> = IsNever<T> extends true ? false : T extends Dictionary ? IsEqual<T, ExplicitlyEmptyObject> extends true ? true : CheckIt<T> : false;
+export {};
 //# sourceMappingURL=IsObjectLiteral.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsObjectLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsObjectLiteral.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,eAAe,EACf,WAAW,EACX,OAAO,EACP,IAAI,EACJ,eAAe,EACf,UAAU,EACX,oBAAwB;AAEzB;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAClD,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC,SAAS,IAAI,GAClC,IAAI,GACJ,eAAe,CAAC,CAAC,CAAC,SAAS,eAAe,GACxC,UAAU,CACR,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EACrC,IAAI,EACJ,KAAK,CACN,GACD,KAAK,GACT,KAAK,CAAC"}
+{"version":3,"file":"IsObjectLiteral.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsObjectLiteral.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,OAAO,EACP,OAAO,EACR,oBAAwB;AAEzB,KAAK,KAAK,CACR,CAAC,SAAS,UAAU,IAClB,YAAY,CAAC,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3C,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,IAAI,GAC9D,KAAK,GACL,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,IAAI,GAChC,KAAK,GACL,IAAI,CAAC;AAGX;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACtD,KAAK,GACL,CAAC,SAAS,UAAU,GACpB,OAAO,CAAC,CAAC,EAAE,qBAAqB,CAAC,SAAS,IAAI,GAC5C,IAAI,GACJ,OAAO,CAAC,CAAC,CAAC,GACZ,KAAK,CAAA"}

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

@@ -1,4 +1,5 @@
-import { IfNever, IfOr, IsScalar, IsUndefined, IfUnion } from "../../index";
+import { IsNever, IsScalar, IsUndefined, IsUnion } from "../../index";
+type Process<T> = [IsNever<T>] extends [true] ? false : [IsScalar<T>] extends [true] ? true : [IsUndefined<T>] extends [true] ? true : [IsUnion<T>] extends [true] ? boolean : false;
 /**
  * **IsOptionalScalar**`<T>`
  *
@@ -6,8 +7,6 @@ import { IfNever, IfOr, IsScalar, IsUndefined, IfUnion } from "../../index";
  *
  * **Related:** `IsScalar`
  */
-export type IsOptionalScalar<T> = IfNever<T, false, IfOr<[
-    IsScalar<T>,
-    IsUndefined<T>
-], true, IfUnion<T, boolean, false>>>;
+export type IsOptionalScalar<T> = Process<T> extends boolean ? Process<T> : never;
+export {};
 //# sourceMappingURL=IsOptionalScalar.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsOptionalScalar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsOptionalScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,WAAW,EACX,OAAO,EACR,oBAAwB;AAGzB;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CACtD;IACE,QAAQ,CAAC,CAAC,CAAC;IAAE,WAAW,CAAC,CAAC,CAAC;CAC5B,EACD,IAAI,EACJ,OAAO,CACL,CAAC,EACD,OAAO,EACP,KAAK,CACN,CACF,CAAC,CAAC"}
+{"version":3,"file":"IsOptionalScalar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsOptionalScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,QAAQ,EACR,WAAW,EACX,OAAO,EACR,oBAAwB;AAEzB,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC3C,KAAK,GACL,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC1B,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC7B,IAAI,GACJ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GACzB,OAAO,GACP,KAAK,CAAC;AAGd;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,OAAO,GAC1D,OAAO,CAAC,CAAC,CAAC,GACV,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { MutableProps, EmptyContainer, Container } from "../../index";
+import { Dictionary, ReadonlyKeys, IsEqual } from "../../index";
 /**
  * **IsReadonlyObject**`<T>`
  *
@@ -8,5 +8,5 @@ import { MutableProps, EmptyContainer, Container } from "../../index";
  *
  * - Note: objects with no properties return `false`
  */
-export type IsReadonlyObject<T> = T extends Container ? EmptyContainer<MutableProps<T>> extends true ? EmptyContainer<T> extends true ? false : true : false : false;
+export type IsReadonlyObject<T> = T extends Dictionary ? IsEqual<ReadonlyKeys<T>, keyof T> : false;
 //# sourceMappingURL=IsReadonlyObject.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsReadonlyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsReadonlyObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,YAAY,EAAG,cAAc,EAAE,SAAS,EAAE,oBAAwB;AAE5E;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GACjD,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC1C,cAAc,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,KAAK,GAAE,IAAI,GAC5C,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"IsReadonlyObject.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsReadonlyObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAI,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,oBAAwB;AAEtE;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,GAClD,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACjC,KAAK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { Scalar, IsBoolean, IsNull, IsSymbol, IsNumber, IfOr, IsString, IfNever, IfUnion, IfExtends } from "../../index";
+import { IfNever, Scalar } from "../../index";
 /**
  * **IsScalar**`<T>`
  *
@@ -13,11 +13,5 @@ import { Scalar, IsBoolean, IsNull, IsSymbol, IsNumber, IfOr, IsString, IfNever,
  *
  * **Related:** `IsOptionalScalar`
  */
-export type IsScalar<T> = IfNever<T, false, IfOr<[
-    IsString<T>,
-    IsNumber<T>,
-    IsBoolean<T>,
-    IsNull<T>,
-    IsSymbol<T>
-], true, IfUnion<T, IfExtends<T, Scalar, true, boolean>, false>>>;
+export type IsScalar<T> = IfNever<T, false, T extends Scalar ? true : false>;
 //# sourceMappingURL=IsScalar.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IsScalar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,SAAS,EACT,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,OAAO,EACP,SAAS,EACV,oBAAwB;AAKzB;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAC1C,IAAI,CACF;IACE,QAAQ,CAAC,CAAC,CAAC;IACX,QAAQ,CAAC,CAAC,CAAC;IACX,SAAS,CAAC,CAAC,CAAC;IACZ,MAAM,CAAC,CAAC,CAAC;IACT,QAAQ,CAAC,CAAC,CAAC;CACd,EACC,IAAI,EACJ,OAAO,CACL,CAAC,EACD,SAAS,CACP,CAAC,EAAE,MAAM,EACT,IAAI,EACJ,OAAO,CACR,EACD,KAAK,CACN,CACF,CAAC,CAAC"}
+{"version":3,"file":"IsScalar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsScalar.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACP,oBAAwB;AAKzB;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsSingleChar.d.ts","sourceRoot":"","sources":["../../../../src/types/boolean-logic/operators/IsSingleChar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAG,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,oBAAwB;AAE/D;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC1C,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GACjB,IAAI,GACJ,EAAE,CACA,eAAe,CAAC,CAAC,CAAC,EAClB,KAAK,EACL,OAAO,CACR,GACH,KAAK,CAAC"}