@dereekb/util 9.25.16 → 10.0.0

package/src/lib/type.d.ts

@@ -3,14 +3,14 @@ import { Maybe } from './value/maybe.type';
 /**
  * Boolean, string or number value.
  */
-export declare type PrimativeValue = boolean | string | number;
+export type PrimativeValue = boolean | string | number;
 /**
  * Class typing, restricted to types that have a constructor via the new keyword.
  */
-export declare type ClassType<T = unknown> = {
+export type ClassType<T = unknown> = {
     new (...args: unknown[]): T;
 };
-export declare type ObjectWithConstructor = {
+export type ObjectWithConstructor = {
     constructor: Function;
 };
 /**
@@ -27,7 +27,7 @@ export declare function isObjectWithConstructor(obj: any): obj is ObjectWithCons
  * @returns
  */
 export declare function isClassLikeType(obj: unknown): obj is ClassLikeType;
-export declare type FunctionType = 'function' | 'class' | 'arrow';
+export type FunctionType = 'function' | 'class' | 'arrow';
 /**
  * Returns the input value's function type, or null if not a function.
  *
@@ -45,42 +45,42 @@ export declare function isNonClassFunction(x: unknown): x is Function;
 /**
  * Similar to ClassType, but allows for abstract classes.
  */
-export declare type ClassLikeType<T = unknown> = abstract new (...args: unknown[]) => T;
+export type ClassLikeType<T = unknown> = abstract new (...args: unknown[]) => T;
 /**
  * Special type used to defined other type definitions that state the defined type has every key of one type, but each key has a single/new value type.
  */
-export declare type KeyValueTransformMap<T, V, X extends keyof T = keyof T> = {
+export type KeyValueTransformMap<T, V, X extends keyof T = keyof T> = {
     [K in X]: V;
 };
-export declare type StringKeyValueTransformMap<T, V> = {
+export type StringKeyValueTransformMap<T, V> = {
     [K in keyof T as string]: V;
 };
-export declare type KeysAsStrings<T> = {
+export type KeysAsStrings<T> = {
     [K in keyof T as string]: T[K];
 };
-export declare type ValuesTypesAsArray<T> = T[keyof T][];
+export type ValuesTypesAsArray<T> = T[keyof T][];
 /**
  * Converts the input value to a string, if possible. Never otherwise.
  */
-export declare type KeyAsString<K> = `${KeyCanBeString<K>}`;
-export declare type KeyCanBeString<K> = K extends number | boolean | string | null | undefined ? K : never;
-export declare type BooleanKeyValueTransformMap<T> = KeyValueTransformMap<T, boolean>;
+export type KeyAsString<K> = `${KeyCanBeString<K>}`;
+export type KeyCanBeString<K> = K extends number | boolean | string | null | undefined ? K : never;
+export type BooleanKeyValueTransformMap<T> = KeyValueTransformMap<T, boolean>;
 /**
  * Merges the types T and R, but replaces keys within T with those in R.
  */
-export declare type MergeReplace<T, R> = Merge<T, R>;
+export type MergeReplace<T, R> = Merge<T, R>;
 /**
  * Similar to MergeReplace, but only allows keys that are defined within T.
  */
-export declare type Replace<T, R> = StrictOmit<MergeReplace<T, R>, Exclude<keyof R, keyof T>>;
+export type Replace<T, R> = StrictOmit<MergeReplace<T, R>, Exclude<keyof R, keyof T>>;
 /**
  * Similar to Replace, but all types that were not replaced are set to the third type (default unknown).
  */
-export declare type ReplaceType<I extends object, O extends object, X = unknown> = {
+export type ReplaceType<I extends object, O extends object, X = unknown> = {
     [K in keyof I]: K extends keyof O ? O[K] : X;
 };
-export declare type OnlyStringKeys<T> = PickProperties<T, 'string'>;
-export declare type RemoveIndex<T> = {
+export type OnlyStringKeys<T> = PickProperties<T, 'string'>;
+export type RemoveIndex<T> = {
     [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
 };
 /**
@@ -88,62 +88,62 @@ export declare type RemoveIndex<T> = {
  *
  * https://stackoverflow.com/questions/51954558/how-can-i-remove-a-wider-type-from-a-union-type-without-removing-its-subtypes-in/51955852#51955852
  */
-export declare type KnownKeys<T> = keyof RemoveIndex<T>;
+export type KnownKeys<T> = keyof RemoveIndex<T>;
 /**
  * Makes the input key(s) required.
  */
-export declare type RequiredOnKeys<T, K> = K extends keyof T ? Omit<T, K> & Required<Pick<T, K>> : T;
+export type RequiredOnKeys<T, K> = K extends keyof T ? Omit<T, K> & Required<Pick<T, K>> : T;
 /**
  * Makes the input key(s) partials.
  */
-export declare type PartialOnKeys<T, K> = K extends keyof T ? Omit<T, K> & Partial<Pick<T, K>> : T;
+export type PartialOnKeys<T, K> = K extends keyof T ? Omit<T, K> & Partial<Pick<T, K>> : T;
 /**
  * Returns only properties that have string keys.
  */
-export declare type StringKeyProperties<T> = NonNever<{
+export type StringKeyProperties<T> = NonNever<{
     [K in keyof T]: K extends string ? T[K] : never;
 }>;
 /**
  * Returns the name of all keys that are strings.
  */
-export declare type StringKeyPropertyKeys<T> = keyof StringKeyProperties<T>;
+export type StringKeyPropertyKeys<T> = keyof StringKeyProperties<T>;
 /**
  * Makes a readonly type able to be configured. Useful for configurating readonly types before they are used.
  */
-export declare type Configurable<T> = Writable<T>;
+export type Configurable<T> = Writable<T>;
 /**
  * StringOrder of all keys of an object.
  *
  * NOTE: Intellisense may not return the correct order.
  */
-export declare type CommaSeparatedKeyOrderOfObject<T extends object> = CommaSeparatedKeyOrder<`${KeyCanBeString<keyof T>}`>;
-export declare type CommaSeparatedKeyOrder<T extends string> = StringOrder<T, ','>;
+export type CommaSeparatedKeyOrderOfObject<T extends object> = CommaSeparatedKeyOrder<`${KeyCanBeString<keyof T>}`>;
+export type CommaSeparatedKeyOrder<T extends string> = StringOrder<T, ','>;
 /**
  * StringCombinations of all keys of an object.
  */
-export declare type CommaSeparatedKeyCombinationsOfObject<T extends object> = CommaSeparatedKeyCombinations<`${KeyCanBeString<keyof T>}`>;
-export declare type CommaSeparatedKeyCombinations<T extends string> = StringCombination<T, ','>;
+export type CommaSeparatedKeyCombinationsOfObject<T extends object> = CommaSeparatedKeyCombinations<`${KeyCanBeString<keyof T>}`>;
+export type CommaSeparatedKeyCombinations<T extends string> = StringCombination<T, ','>;
 /**
  * StringConcatenationApproximation of keys of an object in approximate order.
  */
-export declare type CommaSeparatedKeysOfObject<T extends object> = CommaSeparatedKeys<`${KeyCanBeString<keyof T>}`>;
-export declare type CommaSeparatedKeys<T extends string> = StringConcatenationApproximation<T, ','>;
+export type CommaSeparatedKeysOfObject<T extends object> = CommaSeparatedKeys<`${KeyCanBeString<keyof T>}`>;
+export type CommaSeparatedKeys<T extends string> = StringConcatenationApproximation<T, ','>;
 /**
  * StringConcatenation of all keys of an object in no particular order.
  *
  * May fail for more complex types, requiring the use of CommaSeparatedKeysOfObject.
  */
-export declare type AllCommaSeparatedKeysOfObject<T extends object> = AllCommaSeparatedKeys<`${KeyCanBeString<keyof T>}`>;
-export declare type AllCommaSeparatedKeys<T extends string> = StringConcatenation<T, ','>;
+export type AllCommaSeparatedKeysOfObject<T extends object> = AllCommaSeparatedKeys<`${KeyCanBeString<keyof T>}`>;
+export type AllCommaSeparatedKeys<T extends string> = StringConcatenation<T, ','>;
 /**
  * StringConcatenationOrder of all keys of an object in ascending order.
  *
  * NOTE: Intellisense may not return the correct order.
  */
-export declare type OrderedCommaSeparatedKeysOfObject<T extends object> = OrderedCommaSeparatedKeys<`${KeyCanBeString<keyof T>}`>;
-export declare type OrderedCommaSeparatedKeys<T extends string> = StringConcatenationOrder<T, ','>;
-export declare type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
-export declare type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;
+export type OrderedCommaSeparatedKeysOfObject<T extends object> = OrderedCommaSeparatedKeys<`${KeyCanBeString<keyof T>}`>;
+export type OrderedCommaSeparatedKeys<T extends string> = StringConcatenationOrder<T, ','>;
+export type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+export type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;
 /**
  * A type that merges all combinations of strings together using a separator, but restricts the result to ascending lexigraphical order.
  *
@@ -156,7 +156,7 @@ export declare type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ?
  *
  * https://stackoverflow.com/a/65157132
  */
-export declare type StringOrder<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? SELF : // This works because the values of S are always sorted and interpreted in an ascending order
+export type StringOrder<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? SELF : // This works because the values of S are always sorted and interpreted in an ascending order
 `${StringOrder<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` | StringOrder<Exclude<S, SELF>, SEPARATOR> | SELF : never : never;
 /**
  * A type that merges all combinations of strings together using a separator.
@@ -164,7 +164,7 @@ export declare type StringOrder<S extends string, SEPARATOR extends string> = Po
  * Example:
  * 'a' | 'b' | 'c' w/ ',' -> 'a' | 'b' | 'c' | 'a,b' | 'b,a' | 'c,a,b' | etc...
  */
-export declare type StringCombination<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? SELF : `${StringCombination<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${StringCombination<Exclude<S, SELF>, SEPARATOR>}` | StringCombination<Exclude<S, SELF>, SEPARATOR> | SELF : never : never;
+export type StringCombination<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? SELF : `${StringCombination<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${StringCombination<Exclude<S, SELF>, SEPARATOR>}` | StringCombination<Exclude<S, SELF>, SEPARATOR> | SELF : never : never;
 /**
  * A type that merges all the input strings together and requires them sorted and interpreted in an ascending order
  *
@@ -173,18 +173,18 @@ export declare type StringCombination<S extends string, SEPARATOR extends string
  * Example:
  * 'a' | 'c' | 'b' w/ ',' -> 'a,b,c'
  */
-export declare type StringConcatenationOrder<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? `${SELF}` : `${StringConcatenationOrder<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` : never : never;
+export type StringConcatenationOrder<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? `${SELF}` : `${StringConcatenationOrder<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` : never : never;
 /**
  * A type that merges all the input strings together using a separator.
  *
  * Example:
  * 'a' | 'b' | 'c' w/ ',' -> 'a,b,c' | 'a,c,b' | 'b,a,c' | etc...
  */
-export declare type StringConcatenation<S extends string, SEPARATOR extends string> = StringConcatenationMany<S, SEPARATOR>;
+export type StringConcatenation<S extends string, SEPARATOR extends string> = StringConcatenationMany<S, SEPARATOR>;
 /**
  * Used to "approximate" larger concatenations. In reality, this just excludes the earlier types from being present in the middle.
  */
-export declare type StringConcatenationApproximation<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? `${SELF}` : `${StringConcatenationApproximation<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${StringConcatenationApproximation<Exclude<S, SELF>, SEPARATOR>}` : never : never;
+export type StringConcatenationApproximation<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer SELF ? SELF extends string ? Exclude<S, SELF> extends never ? `${SELF}` : `${StringConcatenationApproximation<Exclude<S, SELF>, SEPARATOR>}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${StringConcatenationApproximation<Exclude<S, SELF>, SEPARATOR>}` : never : never;
 /**
  * Creates the concatenations for the input.
  *
@@ -192,14 +192,14 @@ export declare type StringConcatenationApproximation<S extends string, SEPARATOR
  *
  * The max number of strings allowed is 7. If there are more than 7 strings passed, this function will use StringConcatenationApproximation.
  */
-export declare type StringConcatenationMany<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer ONE ? ONE extends string ? PopUnion<Exclude<S, ONE>> extends infer TWO ? TWO extends string ? Exclude<S, ONE | TWO> extends never ? StringConcatinateTwo<ONE, TWO, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO>> extends infer THREE ? THREE extends string ? Exclude<S, ONE | TWO | THREE> extends never ? StringConcatinateThree<ONE, TWO, THREE, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE>> extends infer FOUR ? FOUR extends string ? Exclude<S, ONE | TWO | THREE | FOUR> extends never ? StringConcatinateFour<ONE, TWO, THREE, FOUR, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR>> extends infer FIVE ? FIVE extends string ? Exclude<S, ONE | TWO | THREE | FOUR | FIVE> extends never ? StringConcatinateFive<ONE, TWO, THREE, FOUR, FIVE, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR | FIVE>> extends infer SIX ? SIX extends string ? Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX> extends never ? StringConcatinateSix<ONE, TWO, THREE, FOUR, FIVE, SIX, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX>> extends infer SEVEN ? SEVEN extends string ? Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX | SEVEN> extends never ? StringConcatinateSeven<ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX | SEVEN>> extends infer EIGHT ? EIGHT extends string ? StringConcatenationApproximation<S, SEPARATOR> : never : StringConcatinateSeven<ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, SEPARATOR> : never : StringConcatinateSix<ONE, TWO, THREE, FOUR, FIVE, SIX, SEPARATOR> : never : StringConcatinateFive<ONE, TWO, THREE, FOUR, FIVE, SEPARATOR> : never : StringConcatinateFour<ONE, TWO, THREE, FOUR, SEPARATOR> : never : StringConcatinateThree<ONE, TWO, THREE, SEPARATOR> : StringConcatinateTwo<ONE, TWO, SEPARATOR> : StringConcatinateTwo<ONE, TWO, SEPARATOR> : never : ONE : never : never;
-export declare type StringConcatinateTwo<LEFT extends string, SELF extends string, SEPARATOR extends string> = `${LEFT}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${LEFT}`;
-export declare type StringConcatinateThree<LEFT extends string, RIGHT extends string, SELF extends string, SEPARATOR extends string> = `${LEFT}${SEPARATOR}${SELF}${SEPARATOR}${RIGHT}` | `${LEFT}${SEPARATOR}${RIGHT}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${RIGHT}${SEPARATOR}${LEFT}` | `${SELF}${SEPARATOR}${LEFT}${SEPARATOR}${RIGHT}` | `${RIGHT}${SEPARATOR}${LEFT}${SEPARATOR}${SELF}` | `${RIGHT}${SEPARATOR}${SELF}${SEPARATOR}${LEFT}`;
-export declare type StringConcatinateFour<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, SEPARATOR extends string> = `${StringConcatinateThree<ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}` | `${StringConcatinateThree<TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateThree<THREE, FOUR, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateThree<FOUR, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}`;
-export declare type StringConcatinateFive<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, FIVE extends string, SEPARATOR extends string> = `${StringConcatinateFour<ONE, TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${FIVE}` | `${StringConcatinateFour<TWO, THREE, FOUR, FIVE, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateFour<THREE, FOUR, FIVE, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateFour<FOUR, FIVE, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}` | `${StringConcatinateFour<FIVE, ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}`;
-export declare type StringConcatinateSix<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, FIVE extends string, SIX extends string, SEPARATOR extends string> = `${StringConcatinateFive<ONE, TWO, THREE, FOUR, FIVE, SEPARATOR>}${SEPARATOR}${SIX}` | `${StringConcatinateFive<TWO, THREE, FOUR, FIVE, SIX, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateFive<THREE, FOUR, FIVE, SIX, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateFive<FOUR, FIVE, SIX, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}` | `${StringConcatinateFive<FIVE, SIX, ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}` | `${StringConcatinateFive<SIX, ONE, TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${FIVE}`;
-export declare type StringConcatinateSeven<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, FIVE extends string, SIX extends string, SEVEN extends string, SEPARATOR extends string> = `${StringConcatinateSix<SEVEN, ONE, TWO, THREE, FOUR, FIVE, SEPARATOR>}${SEPARATOR}${SIX}` | `${StringConcatinateSix<TWO, THREE, FOUR, FIVE, SIX, SEVEN, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateSix<THREE, FOUR, FIVE, SIX, SEVEN, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateSix<FOUR, FIVE, SIX, SEVEN, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}` | `${StringConcatinateSix<FIVE, SIX, SEVEN, ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}` | `${StringConcatinateSix<SIX, SEVEN, ONE, TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${FIVE}`;
-export declare type IsSingleCharacter<S extends string> = PopUnion<S> extends infer SELF ? (Exclude<S, SELF> extends never ? S : never) : never;
-export declare type HasTwoOrMoreCharacters<S extends string> = PopUnion<S> extends infer FIRST ? FIRST extends string ? PopUnion<Exclude<S, FIRST>> extends infer SECOND ? SECOND extends string ? S : never : never : never : never;
-export declare type HasThreeCharacters<S extends string> = PopUnion<S> extends infer FIRST ? FIRST extends string ? PopUnion<Exclude<S, FIRST>> extends infer SECOND ? SECOND extends string ? PopUnion<Exclude<S, FIRST | SECOND>> extends infer THIRD ? THIRD extends string ? Exclude<S, FIRST | SECOND | THIRD> extends never ? S : never : never : never : never : never : never : never;
-export declare type HasThreeOrMoreCharacters<S extends string> = PopUnion<S> extends infer FIRST ? FIRST extends string ? PopUnion<Exclude<S, FIRST>> extends infer SECOND ? SECOND extends string ? PopUnion<Exclude<S, FIRST | SECOND>> extends infer THIRD ? THIRD extends string ? S : never : never : never : never : never : never;
+export type StringConcatenationMany<S extends string, SEPARATOR extends string> = PopUnion<S> extends infer ONE ? ONE extends string ? PopUnion<Exclude<S, ONE>> extends infer TWO ? TWO extends string ? Exclude<S, ONE | TWO> extends never ? StringConcatinateTwo<ONE, TWO, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO>> extends infer THREE ? THREE extends string ? Exclude<S, ONE | TWO | THREE> extends never ? StringConcatinateThree<ONE, TWO, THREE, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE>> extends infer FOUR ? FOUR extends string ? Exclude<S, ONE | TWO | THREE | FOUR> extends never ? StringConcatinateFour<ONE, TWO, THREE, FOUR, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR>> extends infer FIVE ? FIVE extends string ? Exclude<S, ONE | TWO | THREE | FOUR | FIVE> extends never ? StringConcatinateFive<ONE, TWO, THREE, FOUR, FIVE, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR | FIVE>> extends infer SIX ? SIX extends string ? Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX> extends never ? StringConcatinateSix<ONE, TWO, THREE, FOUR, FIVE, SIX, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX>> extends infer SEVEN ? SEVEN extends string ? Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX | SEVEN> extends never ? StringConcatinateSeven<ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, SEPARATOR> : PopUnion<Exclude<S, ONE | TWO | THREE | FOUR | FIVE | SIX | SEVEN>> extends infer EIGHT ? EIGHT extends string ? StringConcatenationApproximation<S, SEPARATOR> : never : StringConcatinateSeven<ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, SEPARATOR> : never : StringConcatinateSix<ONE, TWO, THREE, FOUR, FIVE, SIX, SEPARATOR> : never : StringConcatinateFive<ONE, TWO, THREE, FOUR, FIVE, SEPARATOR> : never : StringConcatinateFour<ONE, TWO, THREE, FOUR, SEPARATOR> : never : StringConcatinateThree<ONE, TWO, THREE, SEPARATOR> : StringConcatinateTwo<ONE, TWO, SEPARATOR> : StringConcatinateTwo<ONE, TWO, SEPARATOR> : never : ONE : never : never;
+export type StringConcatinateTwo<LEFT extends string, SELF extends string, SEPARATOR extends string> = `${LEFT}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${LEFT}`;
+export type StringConcatinateThree<LEFT extends string, RIGHT extends string, SELF extends string, SEPARATOR extends string> = `${LEFT}${SEPARATOR}${SELF}${SEPARATOR}${RIGHT}` | `${LEFT}${SEPARATOR}${RIGHT}${SEPARATOR}${SELF}` | `${SELF}${SEPARATOR}${RIGHT}${SEPARATOR}${LEFT}` | `${SELF}${SEPARATOR}${LEFT}${SEPARATOR}${RIGHT}` | `${RIGHT}${SEPARATOR}${LEFT}${SEPARATOR}${SELF}` | `${RIGHT}${SEPARATOR}${SELF}${SEPARATOR}${LEFT}`;
+export type StringConcatinateFour<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, SEPARATOR extends string> = `${StringConcatinateThree<ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}` | `${StringConcatinateThree<TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateThree<THREE, FOUR, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateThree<FOUR, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}`;
+export type StringConcatinateFive<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, FIVE extends string, SEPARATOR extends string> = `${StringConcatinateFour<ONE, TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${FIVE}` | `${StringConcatinateFour<TWO, THREE, FOUR, FIVE, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateFour<THREE, FOUR, FIVE, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateFour<FOUR, FIVE, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}` | `${StringConcatinateFour<FIVE, ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}`;
+export type StringConcatinateSix<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, FIVE extends string, SIX extends string, SEPARATOR extends string> = `${StringConcatinateFive<ONE, TWO, THREE, FOUR, FIVE, SEPARATOR>}${SEPARATOR}${SIX}` | `${StringConcatinateFive<TWO, THREE, FOUR, FIVE, SIX, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateFive<THREE, FOUR, FIVE, SIX, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateFive<FOUR, FIVE, SIX, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}` | `${StringConcatinateFive<FIVE, SIX, ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}` | `${StringConcatinateFive<SIX, ONE, TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${FIVE}`;
+export type StringConcatinateSeven<ONE extends string, TWO extends string, THREE extends string, FOUR extends string, FIVE extends string, SIX extends string, SEVEN extends string, SEPARATOR extends string> = `${StringConcatinateSix<SEVEN, ONE, TWO, THREE, FOUR, FIVE, SEPARATOR>}${SEPARATOR}${SIX}` | `${StringConcatinateSix<TWO, THREE, FOUR, FIVE, SIX, SEVEN, SEPARATOR>}${SEPARATOR}${ONE}` | `${StringConcatinateSix<THREE, FOUR, FIVE, SIX, SEVEN, ONE, SEPARATOR>}${SEPARATOR}${TWO}` | `${StringConcatinateSix<FOUR, FIVE, SIX, SEVEN, ONE, TWO, SEPARATOR>}${SEPARATOR}${THREE}` | `${StringConcatinateSix<FIVE, SIX, SEVEN, ONE, TWO, THREE, SEPARATOR>}${SEPARATOR}${FOUR}` | `${StringConcatinateSix<SIX, SEVEN, ONE, TWO, THREE, FOUR, SEPARATOR>}${SEPARATOR}${FIVE}`;
+export type IsSingleCharacter<S extends string> = PopUnion<S> extends infer SELF ? (Exclude<S, SELF> extends never ? S : never) : never;
+export type HasTwoOrMoreCharacters<S extends string> = PopUnion<S> extends infer FIRST ? FIRST extends string ? PopUnion<Exclude<S, FIRST>> extends infer SECOND ? SECOND extends string ? S : never : never : never : never;
+export type HasThreeCharacters<S extends string> = PopUnion<S> extends infer FIRST ? FIRST extends string ? PopUnion<Exclude<S, FIRST>> extends infer SECOND ? SECOND extends string ? PopUnion<Exclude<S, FIRST | SECOND>> extends infer THIRD ? THIRD extends string ? Exclude<S, FIRST | SECOND | THIRD> extends never ? S : never : never : never : never : never : never : never;
+export type HasThreeOrMoreCharacters<S extends string> = PopUnion<S> extends infer FIRST ? FIRST extends string ? PopUnion<Exclude<S, FIRST>> extends infer SECOND ? SECOND extends string ? PopUnion<Exclude<S, FIRST | SECOND>> extends infer THIRD ? THIRD extends string ? S : never : never : never : never : never : never;

package/src/lib/value/address.d.ts

@@ -2,25 +2,25 @@ import { Maybe } from './maybe.type';
 /**
  * City name
  */
-export declare type CityString = string;
+export type CityString = string;
 /**
  * Full state name
  */
-export declare type StateString = string;
+export type StateString = string;
 /**
  * State code
  */
-export declare type StateCodeString = string;
+export type StateCodeString = string;
 /**
  * Full country name
  */
-export declare type CountryString = string;
+export type CountryString = string;
 /**
  * Country code
  */
-export declare type CountryCodeString = string;
-export declare type AddressLineString = string;
-export declare type ZipCodeString = string;
+export type CountryCodeString = string;
+export type AddressLineString = string;
+export type ZipCodeString = string;
 /**
  * Basic US Address that has 2 lines, a city, state, and zip code.
  */

package/src/lib/value/bound.d.ts

@@ -3,13 +3,13 @@ import { Rectangle } from './vector';
 import { LatLngPoint, LatLngPointInput, LatLngPrecision, LatLngPointFunction } from './point';
 import { DecisionFunction } from './decision';
 import { ArrayOrValue } from '../array';
-export declare type LatLngBoundSouthWestPoint = LatLngPoint;
-export declare type LatLngBoundNothEastPoint = LatLngPoint;
+export type LatLngBoundSouthWestPoint = LatLngPoint;
+export type LatLngBoundNothEastPoint = LatLngPoint;
 export interface LatLngBound {
     sw: LatLngBoundSouthWestPoint;
     ne: LatLngBoundNothEastPoint;
 }
-export declare type LatLngBoundOrPoint = LatLngBound | LatLngPoint;
+export type LatLngBoundOrPoint = LatLngBound | LatLngPoint;
 export declare function isLatLngBound(input: LatLngBound | unknown): input is LatLngBound;
 export declare function copyLatLngBound(input: LatLngBound): LatLngBound;
 export declare function isSameLatLngBound(a: LatLngBound, b: LatLngBound): boolean;
@@ -46,15 +46,15 @@ export declare function latLngBoundWestBound(bound: LatLngBound): number;
 /**
  * Tuple of the sw corner and the north east point.
  */
-export declare type LatLngBoundTuple = [LatLngBoundSouthWestPoint | LatLngPointInput, LatLngBoundNothEastPoint | LatLngPointInput];
-export declare type LatLngBoundTuplePoints = [LatLngPointInput, LatLngPointInput, LatLngPointInput, LatLngPointInput];
-export declare type LatLngBoundInput = LatLngBound | LatLngBoundTuple | LatLngBoundTuplePoints;
+export type LatLngBoundTuple = [LatLngBoundSouthWestPoint | LatLngPointInput, LatLngBoundNothEastPoint | LatLngPointInput];
+export type LatLngBoundTuplePoints = [LatLngPointInput, LatLngPointInput, LatLngPointInput, LatLngPointInput];
+export type LatLngBoundInput = LatLngBound | LatLngBoundTuple | LatLngBoundTuplePoints;
 export declare function latLngBoundTuple(input: LatLngBoundSouthWestPoint | LatLngBoundInput, inputNe?: LatLngBoundNothEastPoint): LatLngBoundTuple;
 /**
  * Converts the input to a LatLngString
  */
-export declare type LatLngBoundTupleFunction = ((input: LatLngBoundSouthWestPoint | LatLngBoundInput, inputNe?: LatLngBoundNothEastPoint) => LatLngBoundTuple) & ((sw: LatLngBoundSouthWestPoint, ne: LatLngBoundNothEastPoint) => LatLngBoundTuple) & ((bound: LatLngBoundInput) => LatLngBoundTuple);
-export declare type LatLngBoundTupleFunctionConfig = LatLngBoundFunctionConfig;
+export type LatLngBoundTupleFunction = ((input: LatLngBoundSouthWestPoint | LatLngBoundInput, inputNe?: LatLngBoundNothEastPoint) => LatLngBoundTuple) & ((sw: LatLngBoundSouthWestPoint, ne: LatLngBoundNothEastPoint) => LatLngBoundTuple) & ((bound: LatLngBoundInput) => LatLngBoundTuple);
+export type LatLngBoundTupleFunctionConfig = LatLngBoundFunctionConfig;
 /**
  * Creates a LatLngBoundTupleFunction
  *
@@ -66,7 +66,7 @@ export declare function latLngBound(input: LatLngBoundSouthWestPoint | LatLngBou
 /**
  * Converts the input to a LatLngBound
  */
-export declare type LatLngBoundFunction = ((input: LatLngBoundSouthWestPoint | LatLngBoundInput, inputNe?: LatLngBoundNothEastPoint) => LatLngBound) & ((sw: LatLngBoundSouthWestPoint, ne: LatLngBoundNothEastPoint) => LatLngBound) & ((bound: LatLngBoundInput) => LatLngBound);
+export type LatLngBoundFunction = ((input: LatLngBoundSouthWestPoint | LatLngBoundInput, inputNe?: LatLngBoundNothEastPoint) => LatLngBound) & ((sw: LatLngBoundSouthWestPoint, ne: LatLngBoundNothEastPoint) => LatLngBound) & ((bound: LatLngBoundInput) => LatLngBound);
 export interface LatLngBoundFunctionConfig {
     /**
      * Point function to use for calculations.
@@ -78,14 +78,14 @@ export interface LatLngBoundFunctionConfig {
     precision?: LatLngPrecision;
 }
 export declare function latLngBoundFunction(config?: LatLngBoundFunctionConfig): LatLngBoundFunction;
-export declare type ExtendLatLngBoundInput = ArrayOrValue<LatLngBoundOrPoint>;
+export type ExtendLatLngBoundInput = ArrayOrValue<LatLngBoundOrPoint>;
 export declare function latLngBoundFromInput(input: ExtendLatLngBoundInput): Maybe<LatLngBound>;
 export declare function extendLatLngBound(bound: LatLngBound, extendWith: ExtendLatLngBoundInput): LatLngBound;
-export declare type LatLngBoundCheckFunction = DecisionFunction<LatLngBoundOrPoint>;
+export type LatLngBoundCheckFunction = DecisionFunction<LatLngBoundOrPoint>;
 /**
  * Function that returns true if the input is entirely within the context's bound.
  */
-export declare type IsWithinLatLngBoundFunction = LatLngBoundCheckFunction & {
+export type IsWithinLatLngBoundFunction = LatLngBoundCheckFunction & {
     readonly _bound: LatLngBound;
 };
 export declare function isWithinLatLngBoundFunction(bound: LatLngBound): IsWithinLatLngBoundFunction;
@@ -94,7 +94,7 @@ export declare function isLatLngPointWithinLatLngBound(point: LatLngPoint, withi
 /**
  * Function that returns true if the input overlaps the context's bound.
  */
-export declare type OverlapsLatLngBoundFunction = LatLngBoundCheckFunction & {
+export type OverlapsLatLngBoundFunction = LatLngBoundCheckFunction & {
     readonly _bound: LatLngBound;
 };
 export declare function latLngBoundOverlapsLatLngBound(a: LatLngBound, b: LatLngBound): boolean;

package/src/lib/value/build.d.ts

@@ -2,8 +2,8 @@ import { Configurable } from '../type';
 /**
  * Denotes a typically read-only like model is being built/configured.
  */
-export declare type Building<T> = Partial<Configurable<T>>;
-export declare type BuildFunction<T> = (base: Building<T>) => void;
+export type Building<T> = Partial<Configurable<T>>;
+export type BuildFunction<T> = (base: Building<T>) => void;
 export interface BuildConfig<T extends object> {
     base?: Building<T>;
     build: BuildFunction<T>;

package/src/lib/value/comparator.d.ts

@@ -1,8 +1,9 @@
+import { ReadValueFunction } from './map';
 import { Maybe } from './maybe.type';
 /**
  * A comparator that returns true if the two input values are considered equivalent.
  */
-export declare type EqualityComparatorFunction<T> = (a: T, b: T) => boolean;
+export type EqualityComparatorFunction<T> = (a: T, b: T) => boolean;
 /**
  * Wraps a EqualityComparatorFunction that handles Maybe values and only uses the comparator when the input values are not null/undefined.
  *
@@ -19,3 +20,48 @@ export declare function safeEqualityComparatorFunction<T>(compare: EqualityCompa
  * @returns
  */
 export declare function safeCompareEquality<T>(a: Maybe<T>, b: Maybe<T>, compare: EqualityComparatorFunction<T>): boolean;
+/**
+ * Function used to compare the values from the input items. Items might not be defined.
+ *
+ * - If the items are both null or both undefined, the function will return true.
+ * - If one is defined and one is undefined, it will return false.
+ * - If one is undefined and one is null the function will return false.
+ */
+export type CompareEqualityWithValueFromItemsFunction<I, V> = ((a: Maybe<I>, b: Maybe<I>) => boolean) & {
+    /**
+     * Used to read the values from the input, if the input is defined.
+     *
+     * @param a
+     * @returns
+     */
+    readonly _readValues: ReadValueFunction<I, V>;
+    /**
+     * Decision function.
+     *
+     * @param a
+     * @param b
+     * @returns
+     */
+    readonly _equalityComparator: EqualityComparatorFunction<V>;
+};
+/**
+ * Creates a new CompareEqualityWithValueFromItemsFunction.
+ *
+ * Convenience function for calling compareEqualityWithValueFromItemsFunctionFactory() and passing the read values and values decision functions.
+ *
+ * @param readValues
+ * @param equalityComparator
+ * @returns
+ */
+export declare function compareEqualityWithValueFromItemsFunction<I, V>(readValues: ReadValueFunction<I, V>, equalityComparator: EqualityComparatorFunction<V>): CompareEqualityWithValueFromItemsFunction<I, V>;
+/**
+ * Function used to compare the values from the input items. Items might not be defined.
+ */
+export type CompareEqualityWithValueFromItemsFunctionFactory<I, V> = ((equalityComparator: EqualityComparatorFunction<V>) => CompareEqualityWithValueFromItemsFunction<I, V>) & Pick<CompareEqualityWithValueFromItemsFunction<I, V>, '_readValues'>;
+/**
+ * Creates a new CompareEqualityWithValueFromItemsFunctionFactory.
+ *
+ * @param readValues
+ * @returns
+ */
+export declare function compareEqualityWithValueFromItemsFunctionFactory<I, V>(readValues: ReadValueFunction<I, V>): CompareEqualityWithValueFromItemsFunctionFactory<I, V>;

package/src/lib/value/comparator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeCompareEquality = exports.safeEqualityComparatorFunction = void 0;
+exports.compareEqualityWithValueFromItemsFunctionFactory = exports.compareEqualityWithValueFromItemsFunction = exports.safeCompareEquality = exports.safeEqualityComparatorFunction = void 0;
 /**
  * Wraps a EqualityComparatorFunction that handles Maybe values and only uses the comparator when the input values are not null/undefined.
  *
@@ -23,4 +23,38 @@ function safeCompareEquality(a, b, compare) {
     return safeEqualityComparatorFunction(compare)(a, b);
 }
 exports.safeCompareEquality = safeCompareEquality;
+/**
+ * Creates a new CompareEqualityWithValueFromItemsFunction.
+ *
+ * Convenience function for calling compareEqualityWithValueFromItemsFunctionFactory() and passing the read values and values decision functions.
+ *
+ * @param readValues
+ * @param equalityComparator
+ * @returns
+ */
+function compareEqualityWithValueFromItemsFunction(readValues, equalityComparator) {
+    return compareEqualityWithValueFromItemsFunctionFactory(readValues)(equalityComparator);
+}
+exports.compareEqualityWithValueFromItemsFunction = compareEqualityWithValueFromItemsFunction;
+/**
+ * Creates a new CompareEqualityWithValueFromItemsFunctionFactory.
+ *
+ * @param readValues
+ * @returns
+ */
+function compareEqualityWithValueFromItemsFunctionFactory(readValues) {
+    const fn = ((equalityComparator) => {
+        const fn = safeEqualityComparatorFunction((a, b) => {
+            const vA = readValues(a);
+            const vB = readValues(b);
+            return equalityComparator(vA, vB);
+        });
+        fn._readValues = readValues;
+        fn._equalityComparator = equalityComparator;
+        return fn;
+    });
+    fn._readValues = readValues;
+    return fn;
+}
+exports.compareEqualityWithValueFromItemsFunctionFactory = compareEqualityWithValueFromItemsFunctionFactory;
 //# sourceMappingURL=comparator.js.map

package/src/lib/value/comparator.js.map

@@ -1 +1 @@
-{"version":3,"file":"comparator.js","sourceRoot":"","sources":["../../../../../../packages/util/src/lib/value/comparator.ts"],"names":[],"mappings":";;;AAOA;;;;;GAKG;AACH,SAAgB,8BAA8B,CAAI,OAAsC;IACtF,OAAO,CAAC,CAAW,EAAE,CAAW,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAC1F,CAAC;AAFD,wEAEC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAI,CAAW,EAAE,CAAW,EAAE,OAAsC;IACrG,OAAO,8BAA8B,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvD,CAAC;AAFD,kDAEC"}
+{"version":3,"file":"comparator.js","sourceRoot":"","sources":["../../../../../../packages/util/src/lib/value/comparator.ts"],"names":[],"mappings":";;;AASA;;;;;GAKG;AACH,SAAgB,8BAA8B,CAAI,OAAsC;IACtF,OAAO,CAAC,CAAW,EAAE,CAAW,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAC1F,CAAC;AAFD,wEAEC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAI,CAAW,EAAE,CAAW,EAAE,OAAsC;IACrG,OAAO,8BAA8B,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACvD,CAAC;AAFD,kDAEC;AA4BD;;;;;;;;GAQG;AACH,SAAgB,yCAAyC,CAAO,UAAmC,EAAE,kBAAiD;IACpJ,OAAO,gDAAgD,CAAC,UAAU,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAC1F,CAAC;AAFD,8FAEC;AAOD;;;;;GAKG;AACH,SAAgB,gDAAgD,CAAO,UAAmC;IACxG,MAAM,EAAE,GAAG,CAAC,CAAC,kBAA2C,EAAE,EAAE;QAC1D,MAAM,EAAE,GAAG,8BAA8B,CAAC,CAAC,CAAI,EAAE,CAAI,EAAE,EAAE;YACvD,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YACzB,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YACzB,OAAO,kBAAkB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACpC,CAAC,CAA8D,CAAC;QAEhE,EAAE,CAAC,WAAW,GAAG,UAAU,CAAC;QAC5B,EAAE,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;QAE5C,OAAO,EAAE,CAAC;IACZ,CAAC,CAAqE,CAAC;IAEvE,EAAE,CAAC,WAAW,GAAG,UAAU,CAAC;IAC5B,OAAO,EAA4D,CAAC;AACtE,CAAC;AAhBD,4GAgBC"}

package/src/lib/value/cron.d.ts

@@ -2,7 +2,7 @@ import { Minutes } from '../date/date';
 /**
  * A cron schedule expression string
  */
-export declare type CronExpression = string;
+export type CronExpression = string;
 /**
  * Creates a CronExpression for the input number of minutes.
  *

package/src/lib/value/decision.d.ts

@@ -4,9 +4,9 @@ import { Maybe } from './maybe.type';
 /**
  * A map function that derives a boolean from the input.
  */
-export declare type DecisionFunction<I> = MapFunction<I, boolean>;
-export declare type AsyncDecisionFunction<I> = AsyncMapFunction<DecisionFunction<I>>;
-export declare type DecisionFunctionFactory<C, I> = FactoryWithRequiredInput<DecisionFunction<I>, C>;
+export type DecisionFunction<I> = MapFunction<I, boolean>;
+export type AsyncDecisionFunction<I> = AsyncMapFunction<DecisionFunction<I>>;
+export type DecisionFunctionFactory<C, I> = FactoryWithRequiredInput<DecisionFunction<I>, C>;
 export declare function decisionFunction<I>(decision: boolean): DecisionFunction<I>;
 /**
  * Used to invert a decision function by returning the opposite of what it returns.

package/src/lib/value/equal.d.ts

@@ -3,13 +3,13 @@ import { EqualityComparatorFunction } from './comparator';
 /**
  * Used to check if the input object is considered equal to the current context.
  */
-export declare type IsEqualContext<T = unknown> = (x: T) => boolean;
+export type IsEqualContext<T = unknown> = (x: T) => boolean;
 /**
  * Similar to IsEqualContext, but supports an array of objects.
  *
  * Used to check if the input object or array of objects are considered equal to the current context.
  */
-export declare type AreEqualContext<T = unknown> = (x: IterableOrValue<T>) => boolean;
+export type AreEqualContext<T = unknown> = (x: IterableOrValue<T>) => boolean;
 /**
  * Creates an IsEqualContext
  *
@@ -36,9 +36,3 @@ export declare function areEqualContext<T>(contextValue: T, fn: EqualityComparat
  * @returns
  */
 export declare function allObjectsAreEqual<T>(values: IterableOrValue<T>, fn: EqualityComparatorFunction<T>): boolean;
-/**
- * Function used for equivalence comparisons on an object.
- *
- * @deprecated use EqualityComparatorFunction instead.
- */
-export declare type IsEqualFunction<T = unknown> = EqualityComparatorFunction<T>;