@avstantso/concepts 1.0.4 → 1.1.0

package/dist/_global/mapping/_register.d.ts

@@ -1,59 +0,0 @@
-declare namespace AVStantso {
-    namespace Code {
-        namespace Mapping {
-            /**
-             * @summary Mapping factoru function
-             */
-            interface Factory<TMap extends object, TProviderFiled extends AVStantso.Mapping.ProviderKey<TMap> = undefined> {
-                <TTemplate extends AVStantso.Mapping.Template<TMap>, TValueBase extends AVStantso.Mapping.ValueBase<TMap, TProviderFiled> = AVStantso.Mapping.ValueBase<TMap, TProviderFiled>, TValueUnionBase extends AVStantso.Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase> = AVStantso.Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase>>(template: TTemplate): AVStantso.Mapping<TMap, TTemplate, TProviderFiled, TValueBase, TValueUnionBase>;
-            }
-        }
-        /**
-         * @summary Mapping helpers utility
-         */
-        interface Mapping {
-            /**
-             * @summary Find in `TTemplate` of the specified type a property with a name corresponding to `TMap` type
-             * - by value of `TMap[keyof TMap] | TMap[keyof TMap][TProviderFiled]` (with `TProviderFiled`)       *
-             * @template TMap Type of map for create `Mapping.Factory` function
-             * @template TProviderFiled Type of provider field
-             * @param field Provider field. If `undefined` — provider values not supports
-             * @param keyFromValue Get key from value function
-             * @param map Source of `TMap` type parameter. Not used in runtime
-             */
-            <TMap extends object, TProviderFiled extends AVStantso.Mapping.ProviderKey<TMap> = undefined>(field: TProviderFiled, keyFromValue: AVStantso.Mapping.KeyFromValue<TMap>, map?: TMap): Mapping.Factory<TMap, TProviderFiled>;
-            /**
-             * @summary Find in `TTemplate` of the specified type a property with a name corresponding to `TMap` type
-             * - by value of `TMap[keyof TMap]` (without `TProviderFiled`)
-             * @template TMap Type of map for create `Mapping.Factory` function
-             * @param keyFromValue Get key from value function
-             * @param map Source of `TMap` type parameter. Not used in runtime
-             */
-            <TMap extends object>(keyFromValue: AVStantso.Mapping.KeyFromValue<TMap>, map?: TMap): Mapping.Factory<TMap>;
-            /**
-             * @summary Find in `TTemplate` of the specified type a property with a name corresponding to `TMap` type
-             * - by value of `TMap[keyof TMap] | TMap[keyof TMap][TProviderFiled]` (with `TProviderFiled`)       *
-             * @template TMap Type of map for create `Mapping.Factory` function
-             * @template TProviderFiled Type of provider field
-             * @param field Provider field. If `undefined` — provider values not supports
-             * @param map Source of `TMap` type parameter
-             */
-            <TMap extends object, TProviderFiled extends AVStantso.Mapping.ProviderKey<TMap>>(field: TProviderFiled, map: TMap): Mapping.Factory<TMap, TProviderFiled>;
-            /**
-             * @summary Find in `TTemplate` of the specified type a property with a name corresponding to `TMap` type
-             * - by value of `TMap[keyof TMap]` (without `TProviderFiled`)
-             * @template TMap Type of map for create `Mapping.Factory` function
-             * @param keyFromValue Get key from value function
-             * @param map Source of `TMap` type parameter
-             */
-            <TMap extends object>(map: TMap): Mapping.Factory<TMap>;
-        }
-    }
-    interface Code {
-        /**
-         * @summary Mapping helpers utility
-         */
-        Mapping: Code.Mapping;
-    }
-    const Mapping: Code.Mapping;
-}

package/dist/_global/mapping/index.d.ts

@@ -1,2 +0,0 @@
-import './_register';
-import './mapping';

package/dist/_global/mapping/mapping.d.ts

@@ -1,138 +0,0 @@
-declare namespace AVStantso {
-    /**
-     * Debug mode for package developer
-     */
-    type Debug = false;
-    export namespace Mapping {
-        /**
-         * @summary Get key by value method
-         */
-        type KeyFromValue<TMap extends object, TKey extends keyof TMap = keyof TMap, TValue extends TMap[TKey] = TMap[TKey]> = ((value: TValue) => TKey);
-        /**
-         * @summary Mapping `TTemplate` constraint
-         */
-        type Template<TMap extends object> = Partial<Record<keyof TMap, unknown>>;
-        /**
-         * @summary Mapping `TProviderFiled` constraint
-         */
-        type ProviderKey<TMap extends object> = keyof TMap[keyof TMap];
-        /**
-         * @summary Mapping `TValueBase` constraint
-         */
-        type ValueBase<TMap extends object, TProviderFiled extends ProviderKey<TMap>> = TMap[keyof TMap] | (TProviderFiled extends undefined ? never : TMap[keyof TMap][TProviderFiled]);
-        /**
-         * @summary Mapping `TValueUnionBase` constraint
-         */
-        type ValueUnionBase<TMap extends object, TProviderFiled extends ProviderKey<TMap>, TValueBase extends ValueBase<TMap, TProviderFiled> = ValueBase<TMap, TProviderFiled>> = TProviderFiled extends undefined ? TValueBase : Provider.Union.Make<TProviderFiled, TValueBase>;
-    }
-    type _ValueOfField<TMap extends object, TProviderFiled extends Mapping.ProviderKey<TMap>, TValueBase extends Mapping.ValueBase<TMap, TProviderFiled> = Mapping.ValueBase<TMap, TProviderFiled>, TValue extends Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase> = Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase>> = TProviderFiled extends undefined ? TValue : TValue extends Provider.Union<Provider<TProviderFiled, TValueBase>> ? Provider.Value.Make<TValue, TProviderFiled, TValueBase> : never;
-    type _Result<TMap extends object, TTemplate extends Mapping.Template<TMap>, TProviderFiled extends Mapping.ProviderKey<TMap>, TValueBase extends Mapping.ValueBase<TMap, TProviderFiled>, TReversedMap extends TS.Structure.Reverse<TMap, TProviderFiled>, TValue extends Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase>, TExclude extends Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase>, VF extends _ValueOfField<TMap, TProviderFiled, TValueBase, TValue> = _ValueOfField<TMap, TProviderFiled, TValueBase, TValue>, EF extends _ValueOfField<TMap, TProviderFiled, TValueBase, TExclude> = _ValueOfField<TMap, TProviderFiled, TValueBase, TExclude>, V extends Exclude<VF, EF> = Exclude<VF, EF>, MK extends Extract<V, keyof TReversedMap> = Extract<V, keyof TReversedMap>, TK extends Extract<TReversedMap[MK], keyof TTemplate> = Extract<TReversedMap[MK], keyof TTemplate>, R extends TTemplate[TK] = TTemplate[TK]> = {
-        TProviderFiled: TProviderFiled;
-        TValueBase: TValueBase;
-        TValue: TValue;
-        TExclude: TExclude;
-        VF: VF;
-        EF: EF;
-        V: V;
-        MK: MK;
-        TK: TK;
-        R: R;
-        TReversedMap: {
-            [K in keyof TReversedMap]: TReversedMap[K];
-        };
-    };
-    /**
-     * @summary Find in `TTemplate` of the specified type a property with a name corresponding to `TMap` type
-     * - by value of `TMap[keyof TMap]` (without `TProviderFiled`)
-     * - by value of `TMap[keyof TMap] | TMap[keyof TMap][TProviderFiled]` (with `TProviderFiled`)
-     * @template TMap Source map for matching
-     * @template TTemplate Template for matching
-     * @template TProviderFiled Optionally `TMap` subfield for matching
-     * @template TValueBase Base value type.
-     * @template TValueUnionBase Base value provider union type.
-     * @template TInferReversedMap Сalculated `value-key` reversed `TMap`. ⛔ Don`t need set manually
-     * @returns Function type for finding. ⛔ Don`t need set it`s templates manually
-     * @example
-     * namespace PlatformerAction {
-     *   export type Move = (x: number, scream: string) => Promise<unknown>;
-     *   export type Jump = (y: number, spin: boolean) => Promise<unknown>;
-     *   export type NoMove = (sound: object) => Promise<unknown>;
-     * }
-     * type PlatformerAction = {
-     *   top: PlatformerAction.Jump;
-     *   left: PlatformerAction.Move;
-     *   bottom: PlatformerAction.NoMove;
-     *   right: PlatformerAction.Move;
-     *   center: PlatformerAction.NoMove;
-     * };
-     * 
-     * //#region Simple
-     * type SimpleEnum = {
-     *   top: 1;
-     *   left: 2;
-     *   bottom: 3;
-     *   right: 4;
-     *   center: -1;
-     * };
-     * 
-     * type SimpleMapping = Mapping<SimpleEnum, PlatformerAction>;
-     * // Implementation not metter for this example
-     * const simpleMapper = (() => null as null) as unknown as SimpleMapping;
-     * 
-     * const SIMPLE_RESULTS = {
-     *   top: simpleMapper(1),
-     *   left: simpleMapper(2),
-     *   bottom: simpleMapper(3),
-     *   right: simpleMapper(4),
-     *   center: simpleMapper(-1)
-     * };
-     * 
-     * type SimpleResults = typeof SIMPLE_RESULTS;
-     * 
-     * type SimpleChecks = [
-     *   CheckType<SimpleResults['top'], PlatformerAction.Jump>,
-     *   CheckType<SimpleResults['left'], PlatformerAction.Move>,
-     *   CheckType<SimpleResults['bottom'], PlatformerAction.NoMove>,
-     *   CheckType<SimpleResults['right'], PlatformerAction.Move>,
-     *   CheckType<SimpleResults['center'], PlatformerAction.NoMove>
-     * ];
-     * //#endregion
-     * 
-     * //#region Complex
-     * type ComplexEnum = {
-     *   top: { value: 1, sign: '↑' };
-     *   left: { value: 2, sign: '←' };
-     *   bottom: { value: 3, sign: '↓' };
-     *   right: { value: 4, sign: '→' };
-     *   center: { value: -1, sign: '⊕' };
-     * };
-     * 
-     * type ComplexMapping = Mapping<ComplexEnum, PlatformerAction, 'value'>;
-     * 
-     * // Implementation not metter for this example
-     * const complexMapper = (() => null as null) as unknown as ComplexMapping;
-     * 
-     * const COMPLEX_RESULTS = {
-     *   top: complexMapper(1),
-     *   left: complexMapper(2),
-     *   bottom: complexMapper(3),
-     *   right: complexMapper(4),
-     *   center: complexMapper(-1)
-     * };
-     * 
-     * type ComplexResults = typeof COMPLEX_RESULTS;
-     * 
-     * type ComplexChecks = [
-     *   CheckType<ComplexResults['top'], PlatformerAction.Jump>,
-     *   CheckType<ComplexResults['left'], PlatformerAction.Move>,
-     *   CheckType<ComplexResults['bottom'], PlatformerAction.NoMove>,
-     *   CheckType<ComplexResults['right'], PlatformerAction.Move>,
-     *   CheckType<ComplexResults['center'], PlatformerAction.NoMove>
-     * ];
-     * //#endregion
-     */
-    export type Mapping<TMap extends object, TTemplate extends Mapping.Template<TMap>, TProviderFiled extends Mapping.ProviderKey<TMap> = undefined, TValueBase extends Mapping.ValueBase<TMap, TProviderFiled> = Mapping.ValueBase<TMap, TProviderFiled>, TValueUnionBase extends Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase> = Mapping.ValueUnionBase<TMap, TProviderFiled, TValueBase>, TInferReversedMap extends TS.Structure.Reverse<TMap, TProviderFiled> = TS.Structure.Reverse<TMap, TProviderFiled>> = [keyof TInferReversedMap] extends [never] ? 'TMap must have values statisfy TS.Key or TMap[keyof TMap][TProviderFiled] must statisfy TS.Key' : <TInferValue extends TValueUnionBase, TInferExclude extends TValueUnionBase = never, TInferResult extends _Result<TMap, TTemplate, TProviderFiled, TValueBase, TInferReversedMap, TInferValue, TInferExclude> = _Result<TMap, TTemplate, TProviderFiled, TValueBase, TInferReversedMap, TInferValue, TInferExclude>>(value: TInferValue, exclude?: TInferExclude) => Debug extends true ? {
-        [K in keyof TInferResult]: TInferResult[K];
-    } : TInferResult['R'];
-    export {};
-}

package/dist/_global/mock.d.ts

@@ -1,11 +0,0 @@
-declare namespace AVStantso {
-    interface Code {
-        /**
-         * @summary Mock any props of `source`\
-         * as empty function or `undefied` non function\
-         * if not `doNotUseMocking`
-         */
-        Mock<T extends NodeJS.Dict<unknown>>(source?: T, doNotUseMocking?: boolean): T;
-    }
-    const Mock: Code['Mock'];
-}

package/dist/_global/override.d.ts

@@ -1,50 +0,0 @@
-declare namespace AVStantso {
-    /**
-     * @summary Override value structure.
-     * In `Calculator` if `override === undefined` will be used `original`
-     */
-    namespace Override {
-        namespace TypeMap {
-            type OrT = TypeMap | TS.Type.Not.Function;
-            type Parse<T extends OrT> = T extends TypeMap ? T : {
-                T: T;
-                Ext?: undefined;
-            };
-            type IsSimple<T extends OrT, IfTrue = true, IfFalse = false> = TypeMap.Parse<T>['Ext'] extends undefined ? IfTrue : IfFalse;
-        }
-        type TypeMap = {
-            T: TS.Type.Not.Function;
-            Ext?: {};
-        };
-        type Context<TTypeMapOrT extends TypeMap.OrT> = {
-            original: TypeMap.Parse<TTypeMapOrT>['T'];
-        } & TypeMap.IsSimple<TTypeMapOrT, {}, TypeMap.Parse<TTypeMapOrT>['Ext']>;
-        type Union<TTypeMapOrT extends TypeMap.OrT> = TypeMap.Parse<TTypeMapOrT>['T'] | Override<TTypeMapOrT>;
-        namespace Calculator {
-            type Calulate<TTypeMapOrT extends TypeMap.OrT> = (override?: Union<TTypeMapOrT>) => TypeMap.Parse<TTypeMapOrT>['T'];
-        }
-        type Calculator<TTypeMapOrT extends TypeMap.OrT> = TypeMap.IsSimple<TTypeMapOrT, (context?: Context<TTypeMapOrT> | TypeMap.Parse<TTypeMapOrT>['T']) => Calculator.Calulate<TTypeMapOrT>, (context?: Context<TTypeMapOrT>) => Calculator.Calulate<TTypeMapOrT>>;
-    }
-    type Override<TTypeMapOrT extends Override.TypeMap.OrT> = (context?: Override.Context<TTypeMapOrT>) => Override.TypeMap.Parse<TTypeMapOrT>['T'];
-    namespace Code {
-        /**
-         * @summary Override utils
-         */
-        interface Override {
-            isContext<TTypeMapOrT extends Override.TypeMap.OrT = Override.TypeMap>(candidate: unknown): candidate is Override.Context<TTypeMapOrT>;
-            /**
-             * @summary Calculator of override value structure
-             */
-            Calculator<TTypeMapOrT extends Override.TypeMap.OrT, TContextOrOriginal extends Override.Context<TTypeMapOrT> | Override.TypeMap.Parse<TTypeMapOrT>['T']>(context?: TContextOrOriginal): (override: Override.Union<TTypeMapOrT>) => TContextOrOriginal extends {
-                original: infer R;
-            } ? R : TContextOrOriginal;
-        }
-    }
-    interface Code {
-        /**
-         * @summary Override utils
-         */
-        Override: Code.Override;
-    }
-    const Override: Code.Override;
-}

package/dist/_global/perform/_register.d.ts

@@ -1,107 +0,0 @@
-declare namespace AVStantso {
-    type SysPromise<T> = Promise<T>;
-    /**
-     * @summary Value or get value function
-     * @template T Value type
-     * @example
-     * expect(Perform(1)).toBe(1);
-     * expect(Perform(() => 2)).toBe(2);
-     * expect(Perform((m, n) => m * n, 3, 4)).toBe(12);
-     * 
-     * let x = 0;
-     * expect(Perform((o, p, q) => o + p + q, {
-     *   params: [1, 2, 3],
-     *   afterCallback(r) {
-     *     x += 3 * r;
-     *   }
-     * })).toBe(6);
-     * 
-     * expect(x).toBe(18);
-     */
-    export type Perform<T, TParams extends TS.Arr = never> = TS.Func<T, TParams> | (T extends Function ? never : T);
-    export namespace Perform {
-        namespace Options {
-            type Is = <T, TParams extends TS.Arr = never>(candidate: unknown) => candidate is Perform.Options<T, TParams>;
-        }
-        interface Options<T, TParams extends TS.Arr = never> {
-            afterCallback?: (r?: T) => unknown;
-            params?: TParams;
-        }
-        /**
-         * @summary Result of perform
-         * @template P Perform type
-         */
-        type Result<P extends Perform<any, any>> = P extends TS.Func<infer R> ? R : Exclude<P, TS.Func>;
-        namespace Promise {
-            /**
-             * @summary Value or get value function. Value may be a `Promise<T>`
-             */
-            type Sync<T, TParams extends TS.Arr = never> = Perform<T | SysPromise<T>, TParams>;
-            namespace Sync {
-                /**
-                 * @summary Result of sync perform promise
-                 * @template P Perform type
-                 */
-                type Result<P extends Sync<any, any>> = Awaited<Perform.Result<P>>;
-            }
-            /**
-             * @summary Result of sync perform promise
-             * @template P Perform type
-             */
-            type Result<P extends Perform.Promise<any, any>> = Perform.Result<Awaited<Sync.Result<P>>>;
-        }
-        /**
-         * @summary Value or get value function or promise of value or promise of get value function
-         */
-        type Promise<T, TParams extends TS.Arr = never> = Promise.Sync<T, TParams> | SysPromise<Perform<T, TParams>>;
-    }
-    export namespace Code {
-        namespace Perform {
-            interface Simple {
-                <T, TParams extends AVStantso.TS.Arr = never>(p: AVStantso.Perform<T, TParams>, ...params: TParams): T;
-                <T, TParams extends AVStantso.TS.Arr = never>(p: AVStantso.Perform<T, TParams>, options?: AVStantso.Perform.Options<T, TParams>): T;
-            }
-            interface List {
-                <T, TParams extends AVStantso.TS.Arr = never>(options: AVStantso.Perform.Options<T, TParams>, ...p: AVStantso.Perform<T | T[], TParams>[]): T[];
-                <T, TParams extends AVStantso.TS.Arr = never>(...p: AVStantso.Perform<T | T[], TParams>[]): T[];
-            }
-            namespace Promise {
-                interface Simple {
-                    <T, TParams extends AVStantso.TS.Arr = never>(p: AVStantso.Perform.Promise<T, TParams>, ...params: TParams): SysPromise<T>;
-                    <T, TParams extends AVStantso.TS.Arr = never>(p: AVStantso.Perform.Promise<T, TParams>, options?: AVStantso.Perform.Options<T, TParams>): SysPromise<T>;
-                }
-                interface List {
-                    <T, TParams extends AVStantso.TS.Arr = never>(options: AVStantso.Perform.Options<T, TParams>, ...p: AVStantso.Perform.Promise<T | T[], TParams>[]): SysPromise<T[]>;
-                    <T, TParams extends AVStantso.TS.Arr = never>(...p: AVStantso.Perform.Promise<T | T[], TParams>[]): SysPromise<T[]>;
-                }
-            }
-            /**
-             * @summary `AVStantso.Perform.Promise` utility
-             */
-            interface Promise extends Promise.Simple {
-                List: Promise.List;
-            }
-        }
-        /**
-         * @summary `AVStantso.Perform` utility
-         */
-        interface Perform extends Perform.Simple {
-            Options: {
-                is: AVStantso.Perform.Options.Is;
-            };
-            List: Perform.List;
-            /**
-             * @summary `AVStantso.Perform.Promise` utility
-             */
-            Promise: Perform.Promise;
-        }
-    }
-    export interface Code {
-        /**
-         * @summary `AVStantso.Perform` utility
-         */
-        Perform: Code.Perform;
-    }
-    export const Perform: Code.Perform;
-    export {};
-}

package/dist/_global/perform/index.d.ts

@@ -1 +0,0 @@
-import './_register';

package/dist/_global/provider/_register.d.ts

@@ -1,16 +0,0 @@
-declare namespace AVStantso {
-    namespace Code {
-        /**
-         * @summary `AVStantso.Provider` utility
-         */
-        interface Provider {
-        }
-    }
-    interface Code {
-        /**
-         * @summary `AVStantso.Provider` utility
-         */
-        Provider: Code.Provider;
-    }
-    const Provider: Code.Provider;
-}

package/dist/_global/provider/combination.d.ts

@@ -1,96 +0,0 @@
-declare namespace AVStantso {
-    namespace Provider {
-        namespace _Combination {
-            type Restore<C, Keys extends TS.Keys = globalThis.Extract<TS.Union.ToTuple<keyof C>, TS.Keys>, R extends Combination.Constraint = {
-                __KEYS__?: Keys;
-            } & C> = {
-                [K in keyof R]: R[K];
-            };
-        }
-        type _Combination<PP extends Combination.Params, R = unknown> = PP extends readonly [
-            infer P extends Combination.Param,
-            ...infer Rest extends Combination.Params
-        ] ? P extends Provider.Constraint ? _Combination<Rest, R & Provider.Dry<P>> : P extends Combination.Constraint ? _Combination<Rest, R & Combination.Dry<P>> : never : _Combination.Restore<R>;
-        /**
-         * @summary Providers combination.\
-         * ⚠ Order of `__KEYS__` not warrant
-         * @template PP Array of providers or combinations
-         * @example
-         * type A = Provider<'a', string>;
-         * type B = Provider<'b', number>;
-         * type C = {
-         *   __KEYS__: ['c', 'd', 'e'],
-         *   c: bigint;
-         *   d: object;
-         *   e: unknown[];
-         * };
-         * type F = {
-         *   __KEYS__: ['f'],
-         *   f: () => symbol;
-         * };
-         * 
-         * type R = CheckType<
-         *   Combination<[A, B, C, F]>,
-         *   {
-         *     __KEYS__?: TS.Keys; // ⚠ Order of items not warrant, see below 👇 (RK)
-         *     a: string;
-         *     b: number;
-         *     c: bigint;
-         *     d: object;
-         *     e: unknown[];
-         *     f: () => symbol;
-         *   }
-         * >;
-         * 
-         * type RK = CheckType<
-         *   TS.Array.Sort<globalThis.Extract<R[__KEYS__], string[]>>,
-         *   ['a', 'b', 'c', 'd', 'e', 'f']
-         * >;
-         */
-        export type Combination<PP extends Combination.Params> = _Combination<PP>;
-        export namespace Combination {
-            /**
-             * @summary Providers combination constraint
-             */
-            export type Constraint = {
-                __KEYS__?: readonly TS.Key[];
-            } & {
-                [k: TS.Key]: unknown;
-            };
-            /**
-             * @summary Providers combination param
-             */
-            export type Param = Constraint | Provider.Constraint;
-            /**
-             * @summary Array of providers combination param
-             */
-            export type Params = readonly Param[];
-            type _Dry<C extends Constraint, Keys extends TS.Keys = C[__KEYS__], R = unknown> = Keys extends readonly [infer K extends TS.Key, ...infer Rest extends TS.Keys] ? _Dry<C, Rest, R & Pick<C, K>> : {
-                [K in keyof R]: R[K];
-            };
-            /**
-             * @summary Dry combination without `__KEYS__` and extended fields
-             * @example
-             * type C = {
-             *   __KEYS__: ['a', 'b'],
-             *   a: number;
-             *   b: string;
-             *   c: boolean;
-             * };
-             * 
-             * type D = CheckType<
-             *   Dry<C>, {
-             *     a: number;
-             *     b: string;
-             * 
-             *     __KEYS__?: never;
-             *     c?: never;
-             *   }
-             * >;
-             */
-            export type Dry<C extends Constraint> = _Dry<C>;
-            export {};
-        }
-        export {};
-    }
-}

package/dist/_global/provider/compare.d.ts

@@ -1,47 +0,0 @@
-declare namespace AVStantso {
-    namespace Provider {
-        /**
-         * @summary Compare two `Provider.Value` from `Provider.Union` function
-         * @template P `Provider`
-         * @see Provider type
-         */
-        type Compare<P extends Provider.Constraint> = AVStantso.Compare<Union<P>>;
-        namespace Compare {
-            /**
-             * @summary Make compare two `Provider.Value` from `Provider.Union` function
-             * @template F First `Provider` param
-             * @template S Second `Provider` param
-             * @see Provider type
-             */
-            type Make<F extends First, S = undefined> = Compare<Provider<F, S>>;
-        }
-    }
-    namespace Code {
-        namespace Provider {
-            namespace Compare {
-                /**
-                 * @summary `AVStantso.Provider.Compare` utility options
-                 */
-                type Options<A extends AVStantso.TS.Type.KLD = AVStantso.TS.Type.KLD> = {
-                    /**
-                     * @summary Extract value method
-                     */
-                    extract?: AVStantso.Provider.Extract.Make<A>;
-                };
-            }
-            /**
-             * @summary `AVStantso.Provider.Compare` utility
-             */
-            interface Compare {
-                <K extends AVStantso.TS.Key, L extends AVStantso.TS.Literal>(key: K, type?: L, options?: Compare.Options<AVStantso.TS.Type.KLD<K, L>>): AVStantso.Provider.Compare.Make<K, L>;
-                <Arr extends AVStantso.TS.Type.KLD>(def: Arr, options?: Compare.Options<Arr>): AVStantso.Provider.Compare.Make<Arr>;
-            }
-        }
-        interface Provider {
-            /**
-             * @summary `AVStantso.Provider.Compare` utility
-             */
-            Compare: Provider.Compare;
-        }
-    }
-}

package/dist/_global/provider/extract.d.ts

@@ -1,36 +0,0 @@
-declare namespace AVStantso {
-    namespace Provider {
-        /**
-         * @summary Extract `Provider.Value` from `Provider.Union` function
-         * @template P `Provider`
-         * @see Provider type
-         */
-        type Extract<P extends Provider.Constraint> = <T extends Value<Union<P>, P>>(union: Union<P>) => T;
-        namespace Extract {
-            /**
-             * @summary Make extract `Provider.Value` from `Provider.Union` function
-             * @template F First `Provider` param
-             * @template S Second `Provider` param
-             * @see Provider type
-             */
-            type Make<F extends First, S = undefined> = Extract<Provider<F, S>>;
-        }
-    }
-    namespace Code {
-        namespace Provider {
-            /**
-             * @summary `AVStantso.Provider.Extract` utility
-             */
-            interface Extract {
-                <K extends AVStantso.TS.Key, L extends AVStantso.TS.Literal>(key: K, type?: L): AVStantso.Provider.Extract.Make<K, L>;
-                <Arr extends AVStantso.TS.Type.KLD>(def: Arr): AVStantso.Provider.Extract.Make<Arr>;
-            }
-        }
-        interface Provider {
-            /**
-             * @summary `AVStantso.Provider.Extract` utility
-             */
-            Extract: Provider.Extract;
-        }
-    }
-}

package/dist/_global/provider/force.d.ts

@@ -1,35 +0,0 @@
-declare namespace AVStantso {
-    namespace Provider {
-        /**
-         * @summary Force cast to provider
-         */
-        type Force<P extends Provider.Constraint> = <T extends object>(obj: T) => Partial<Provider.Dry<P>>;
-        namespace Force {
-            /**
-             * @summary Make Force cast to provider
-             * @template F First `Provider` param
-             * @template S Second `Provider` param
-             * @see Provider type
-             */
-            type Make<F extends First, S = undefined> = Force<Provider<F, S>>;
-        }
-    }
-    namespace Code {
-        namespace Provider {
-            /**
-             * @summary Force caster to provider
-             */
-            interface Force {
-                <K extends AVStantso.TS.Key, L extends AVStantso.TS.Literal>(key: K, type?: L): AVStantso.Provider.Force.Make<K, L>;
-                <Arr extends AVStantso.TS.Type.KLD>(def: Arr): AVStantso.Provider.Force.Make<Arr>;
-                <P extends AVStantso.Provider.Constraint>(): AVStantso.Provider.Force<P>;
-            }
-        }
-        interface Provider {
-            /**
-             * @summary Force caster to provider
-             */
-            Force: Provider.Force;
-        }
-    }
-}

package/dist/_global/provider/index.d.ts

@@ -1,10 +0,0 @@
-import './_register';
-import './provider';
-import './strict';
-import './union';
-import './value';
-import './is';
-import './extract';
-import './compare';
-import './combination';
-import './force';

package/dist/_global/provider/is.d.ts

@@ -1,38 +0,0 @@
-declare namespace AVStantso {
-    namespace Provider {
-        /**
-         * @summary A function signature of: `candidate` is `Provider` object
-         * @template P `Provider`
-         * @template K `Provider` infer key
-         * @template B `Provider` infer base type of `T`
-         * @see Provider type
-         */
-        type Is<P extends Constraint, K extends globalThis.Extract<P[__KEY__], keyof P> = globalThis.Extract<P[__KEY__], keyof P>, B extends Pick<P, K> = Pick<P, K>> = <T extends B = B>(candidate: unknown) => candidate is T;
-        namespace Is {
-            /**
-             * @summary Make a function signature of: `candidate` is `Provider` object
-             * @template F First `Provider` param
-             * @template S Second `Provider` param
-             * @see Provider type
-             */
-            type Make<F extends First, S = undefined> = Is<Provider<F, S>>;
-        }
-    }
-    namespace Code {
-        namespace Provider {
-            /**
-             * @summary `AVStantso.Provider.Is` utility
-             */
-            interface Is {
-                <K extends AVStantso.TS.Key, L extends AVStantso.TS.Literal>(key: K, type?: L): AVStantso.Provider.Is.Make<K, L>;
-                <Arr extends AVStantso.TS.Type.KLD>(def: Arr): AVStantso.Provider.Is.Make<Arr>;
-            }
-        }
-        interface Provider {
-            /**
-             * @summary `AVStantso.Provider.Is` utility
-             */
-            Is: Provider.Is;
-        }
-    }
-}