declare let _$_: {
    new (): {};
} & typeof globalThis;
declare class $ extends _$_ {
}
declare namespace $ {
    export type $ = typeof $$;
    export class $$ extends $ {
        static $: $;
    }
    namespace $$ {
        type $$ = $;
    }
    export {};
}

declare namespace $ {
    /**
     * Leave types with specified keys in union type
     *
     * 	// { prop: number; foo: number }
     * 	type only_with_prop = $mol_type_filter_keys< { prop: number; foo: number } | { foo: string }, 'prop' >
     */
    type $mol_type_filter_keys<Type, Keys extends string | number> = Extract<Type, {
        [_ in Keys]?: any;
    }>;
}

declare namespace $ {
    /**
     * Access property type by key for union type
     *
     * 	// number
     * 	type a_type = $mol_type_access< { a: number } | boolean, 'a' >
     */
    type $mol_type_access<Type, Keys extends string | number> = $mol_type_filter_keys<Type, Keys> extends never ? never : Keys extends keyof $mol_type_filter_keys<Type, Keys> ? $mol_type_filter_keys<Type, Keys>[Keys] : never;
}

declare namespace $ {
    /** English alphabet in lowercase **/
    type $mol_type_alphabet_en_lower = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'j' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
    /** English alphabet in uppercase **/
    type $mol_type_alphabet_en_upper = Uppercase<$mol_type_alphabet_en_lower>;
    /** English alphabet **/
    type $mol_type_alphabet_en = $mol_type_alphabet_en_lower | $mol_type_alphabet_en_upper;
}

declare namespace $ {
    /** Russian alphabet in lowercase **/
    type $mol_type_alphabet_ru_lower = 'а' | 'б' | 'в' | 'г' | 'д' | 'е' | 'ё' | 'ж' | 'з' | 'и' | 'й' | 'к' | 'л' | 'м' | 'н' | 'о' | 'п' | 'р' | 'с' | 'т' | 'у' | 'ф' | 'х' | 'ц' | 'ч' | 'ш' | 'щ' | 'ъ' | 'ы' | 'ь' | 'э' | 'ю' | 'я';
    /** Russian alphabet in uppercase **/
    type $mol_type_alphabet_ru_upper = Uppercase<$mol_type_alphabet_ru_lower>;
    /** Russian alphabet **/
    type $mol_type_alphabet_ru = $mol_type_alphabet_ru_lower | $mol_type_alphabet_ru_upper;
}

declare namespace $ {
    /**
     * Return `unknown` when `A` and `B` are the same type. `never` otherwise.
     *
     * 	$mol_type_equals< unknown , any > & number // true
     * 	$mol_type_equals< never , never > & number // false
     */
    type $mol_type_equals<A, B> = (<X>() => X extends A ? 1 : 2) extends (<X>() => X extends B ? 1 : 2) ? true : false;
}

declare namespace $ {
    /** Returns error type, that don't match to normal value. */
    type $mol_type_error<Message, Info = {}> = Message & {
        $mol_type_error: Info;
    };
}

declare namespace $ {
    /**
     * Asserts for equality of `Actual` and `Expected` types.
     */
    type $mol_type_assert<Actual extends $mol_type_equals<Actual, Expected> extends true ? unknown : $mol_type_equals<Actual, any> extends true ? never : $mol_type_error<'Assert failed', {
        actual: Actual;
        expected: Expected;
    }>, Expected extends $mol_type_equals<Actual, Expected> extends true ? unknown : $mol_type_equals<Expected, any> extends true ? never : $mol_type_error<'Assert failed', {
        actual: Actual;
        expected: Expected;
    }>> = Actual;
    /**
     * Asserts for `Actual` type is `never`.
     * @deprecated Use `$mol_type_assert< A, B >`
     *
     * 	$mol_type_assert_never< $mol_type_equals< 1 , 2 > >
     */
    type $mol_type_assert_never<Actual extends never> = Actual;
}

declare namespace $ {
    /**
     * Capitalize type keys.
     *
     * 	// { Foo: 1; Bar: 2 }
     * 	$mol_type_case_capital_keys< { foo: 1; bar: 2 } >
     */
    type $mol_type_case_capital_keys<Type> = {
        [Key in keyof Type as Capitalize<Extract<Key, string>>]: Type[Key];
    };
    /**
     * Capitalize type values.
     *
     * 	// { foo: 'Bar' }
     * 	$mol_type_case_capital_values< { foo: 'bar' } >
     */
    type $mol_type_case_capital_values<Type> = {
        [Key in keyof Type]: Capitalize<Extract<Type[Key], string>>;
    };
}

declare namespace $ {
    /**
     * Lowercase type keys.
     *
     * 	// { foo: 'BAR' }
     * 	$mol_type_case_lower_keys< { FOO: 'BAR' } >
     */
    type $mol_type_case_lower_keys<Type> = {
        [Key in keyof Type as Lowercase<Extract<Key, string>>]: Type[Key];
    };
    /**
     * Lowercase type values.
     *
     * 	// { FOO: 'bar' }
     * 	$mol_type_case_lower_values< { FOO: 'BAR' } >
     */
    type $mol_type_case_lower_values<Type> = {
        [Key in keyof Type]: Lowercase<Extract<Type[Key], string>>;
    };
}

declare namespace $ {
    /**
     * Uppercase type keys.
     *
     * 	// { FOO: 'bar' }
     * 	$mol_type_case_upper_keys< { foo: 'bar' } >
     */
    type $mol_type_case_upper_keys<Type> = {
        [Key in keyof Type as Uppercase<Extract<Key, string>>]: Type[Key];
    };
    /**
     * Uppercase type values.
     *
     * 	// { foo: 'BAR' }
     * 	$mol_type_case_upper_values< { foo: 'bar' } >
     */
    type $mol_type_case_upper_values<Type> = {
        [Key in keyof Type]: Uppercase<Extract<Type[Key], string>>;
    };
}

declare namespace $ {
    /**
     * Fails if `Actual` type is not subtype of `Expected`.
     */
    type $mol_type_enforce<Actual extends Expected, Expected> = Actual;
}

declare namespace $ {
    /**
     * Reqursive converts intersection of records to record of intersections
     *
     * 	// { a : { x : 1 , y : 2 } }
     * 	$mol_type_merge< { a : { x : 1 } }&{ a : { y : 2 } } >
     */
    type $mol_type_merge<Intersection> = Intersection extends (...a: any[]) => any ? Intersection : Intersection extends new (...a: any[]) => any ? Intersection : Intersection extends object ? $mol_type_merge_object<Intersection> extends Intersection ? true extends $mol_type_equals<{
        [Key in keyof Intersection]: Intersection[Key];
    }, Intersection> ? Intersection : {
        [Key in keyof Intersection]: $mol_type_merge<Intersection[Key]>;
    } : Intersection : Intersection;
    /**
     * Flat converts intersection of records to record of intersections
     *
     * 	// { a: 1, b: 2 }
     * 	$mol_type_merge< { a: 1 } & { b: 2 } >
     */
    type $mol_type_merge_object<Intersection> = {
        [Key in keyof Intersection]: Intersection[Key];
    };
}

declare namespace $ {
    /** Replaces properties of `Base` record by properties from `Over`. */
    type $mol_type_override<Base, Over> = Omit<Base, keyof Over> & Over;
}

declare namespace $ {
    /**
     * Fields that can be set to undefined makes optional
     *
     * 	type User = $mol_type_partial_undefined<{ name : string , age : number | undefined }> // { name : string , age? : number | undefined }
     */
    type $mol_type_partial_undefined<Val> = $mol_type_merge<$mol_type_override<Partial<Val>, Pick<Val, {
        [Field in keyof Val]: undefined extends Val[Field] ? never : Field;
    }[keyof Val]>>>;
}

declare namespace $ {
    /**
     * Flat structure key names, leading to non-object types, in tuples. Endpoint specifies structures, whose keys should not be flat.
     *
     * 	// [ 'a', 'd' ] | [ 'a', 'b', 'c' ]
     * 	type keys = $mol_type_flat_keys< { a: { b: { c: number }, d: string } } >
     */
    type $mol_type_flat_keys<Type, Endpoint = never> = Type extends object ? Type extends Readonly<Array<any>> | Function | Promise<any> ? [] : Type extends Endpoint ? [] : {
        [Key in keyof Type]-?: Key extends string ? [
            Key,
            ...$mol_type_flat_keys<Required<Type>[Key], Endpoint>
        ] : never;
    }[keyof Type] : [];
    /**
     * All flat structure key names in tuples. Endpoint specifies structures, whose keys should not be flat.
     *
     * 	// [ 'a' ] | [ 'a', 'b' ] | [ 'a', 'd' ] | [ 'a', 'b', 'c' ]
     * 	type all_keys = $mol_type_flat_keys_all< { a: { b: { c: number }, d: string } } >
     */
    type $mol_type_flat_keys_all<Type, Endpoint = never> = Type extends object ? Type extends Readonly<Array<any>> | Promise<any> ? [] : Type extends Endpoint ? [] : {
        [Key in keyof Type]-?: Key extends string ? [Key] | [
            Key,
            ...$mol_type_flat_keys_all<Required<Type>[Key], Endpoint>
        ] : never;
    }[keyof Type] : [];
}

declare namespace $ {
    /**
     * Returns `Tuple` without first element.
     *
     * 	$mol_type_tail<[ 1 , 2 , 3 ]> // [ 2, 3 ]
     */
    type $mol_type_tail<Tuple extends readonly any[]> = ((...tail: Tuple) => any) extends ((head: any, ...tail: infer Tail) => any) ? Tail : never;
}

declare namespace $ {
    /**
     * Join strings with `Separator`.
     *
     * 	// 'foo%bar%wee'
     * 	$mol_type_string_join< [ 'foo', 'bar', 'wee' ], '%' >
     */
    type $mol_type_string_join<Parts extends Array<string>, Separator extends string> = Parts['length'] extends 0 ? never : Parts['length'] extends 1 ? Parts[0] : Parts['length'] extends 2 ? `${Extract<Parts[0], string>}${'' extends Parts[1] ? '' : Separator}${Extract<Parts[1], string>}` : $mol_type_string_join<[
        $mol_type_string_join<[Parts[0], Parts[1]], Separator>,
        ...$mol_type_tail<$mol_type_tail<Parts>>
    ], Separator>;
}

declare namespace $ {
    /**
     * Split string into parts with separator.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_string_split< 'foo-bar-wee', '-' >
     */
    type $mol_type_string_split<String extends string, Separator extends string = ''> = '' extends String ? [] : String extends `${infer Left}${Separator}${infer Right}` ? [
        ...('' extends Left ? [] : [Left]),
        ...$mol_type_string_split<Right, Separator>
    ] : [String];
}

declare namespace $ {
    /**
     * Returns first element of `Tuple`.
     *
     * 	$mol_type_tail<[ 1 , 2 , 3 ]> // 1
     */
    type $mol_type_head<Tuple extends readonly any[]> = Tuple['length'] extends 0 ? never : Tuple[0];
}

declare namespace $ {
    /**
     * Join strings in snake_case.
     *
     * 	// 'foo_bar_wee'
     * 	$mol_type_case_snake< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_snake<Parts extends Array<string>> = $mol_type_string_join<Parts, '_'>;
    /**
     * Parse snake_case string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_snake_parse< 'foo_bar_wee' >
     */
    export type $mol_type_case_snake_parse<String extends string> = $mol_type_string_split<String, '_'>;
    /**
     * Join strings in kebab-case.
     *
     * 	// 'foo-bar-wee'
     * 	$mol_type_case_kebab< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_kebab<Parts extends Array<string>> = $mol_type_string_join<Parts, '-'>;
    /**
     * Parse kebab-case string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_kebab_parse< 'foo-bar-wee' >
     */
    export type $mol_type_case_kebab_parse<String extends string> = $mol_type_string_split<String, '-'>;
    /**
     * Join strings in dot.case.
     *
     * 	// 'foo.bar.wee'
     * 	$mol_type_case_dot< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_dot<Parts extends Array<string>> = $mol_type_string_join<Parts, '.'>;
    /**
     * Parse dot.case string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_dot_parse< 'foo.bar.wee' >
     */
    export type $mol_type_case_dot_parse<String extends string> = $mol_type_string_split<String, '.'>;
    /**
     * Join strings in camelCase.
     *
     * 	// 'fooBarWee'
     * 	$mol_type_case_camel< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_camel<Parts extends Array<string>> = $mol_type_string_join<[
        Lowercase<$mol_type_head<Parts>>,
        ...Extract<$mol_type_case_capital_values<$mol_type_case_lower_values<$mol_type_tail<Parts>>>, Array<string>>
    ], ''>;
    type camel_temp_separator = '.';
    type camel_replace_with_separator<String extends string> = String extends `${infer Left}${infer Right}` ? `${Left extends Capitalize<Left> ? camel_temp_separator : ''}${Lowercase<Left>}${camel_replace_with_separator<Right>}` : String;
    /**
     * Parse camelCase string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_camel_parse< 'fooBarWee' >
     */
    export type $mol_type_case_camel_parse<String extends string> = $mol_type_string_split<camel_replace_with_separator<String>, camel_temp_separator>;
    /**
     * Join strings in PascalCase.
     *
     * 	// 'FooBarWee'
     * 	$mol_type_case_pascal< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_pascal<Parts extends Array<string>> = $mol_type_string_join<$mol_type_case_capital_values<$mol_type_case_lower_values<Parts>>, ''>;
    /**
     * Parse PascalCase string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_pascal_parse< 'FooBarWee' >
     */
    export type $mol_type_case_pascal_parse<String extends string> = $mol_type_case_camel_parse<String>;
    /**
     * Join strings in Cobra_case.
     *
     * 	// 'Foo_bar_wee'
     * 	$mol_type_case_cobra< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_cobra<Parts extends Array<string>> = $mol_type_string_join<[
        Capitalize<Lowercase<$mol_type_head<Parts>>>,
        ...Extract<$mol_type_case_lower_values<$mol_type_tail<Parts>>, Array<string>>
    ], '_'>;
    /**
     * Parse Cobra_case string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_cobra_parse< 'Foo_bar_wee' >
     */
    export type $mol_type_case_cobra_parse<String extends string> = $mol_type_case_lower_values<$mol_type_string_split<String, '_'>>;
    /**
     * Join strings in SCREAM_CASE.
     *
     * 	// 'FOO_BAR_WEE'
     * 	$mol_type_case_scream< [ 'foo', 'bar', 'wee' ] >
     */
    export type $mol_type_case_scream<Parts extends Array<string>> = $mol_type_string_join<$mol_type_case_upper_values<Parts>, '_'>;
    /**
     * Parse SCREAM_CASE string into parts.
     *
     * 	// [ 'foo', 'bar', 'wee' ]
     * 	$mol_type_case_scream_parse< 'FOO_BAR_WEE' >
     */
    export type $mol_type_case_scream_parse<String extends string> = $mol_type_case_cobra_parse<String>;
    export {};
}

declare namespace $ {
    /**
     * Converts union of types to intersection of same types
     *
     * 	$mol_type_intersect< number | string > // number & string
     */
    type $mol_type_intersect<Union> = (Union extends any ? (_: Union) => void : never) extends ((_: infer Intersection) => void) ? Intersection : never;
}

declare namespace $ {
    /**
     * Volume structure from flat with dot.case key names.
     *
     * 	// { a: { b: number; c: { d: string } } }
     * 	type volume = $mol_type_volume< { 'a.b': number; 'a.c.d': string } >
     */
    type $mol_type_volume<Type extends object> = $mol_type_merge<$mol_type_intersect<{
        [Key in keyof Type]: Key extends `${infer Left}.${infer Right}` ? {
            [_ in Left]: $mol_type_volume<{
                [_ in Right]: Type[Key];
            }>;
        } : $mol_type_partial_undefined<{
            [_ in Key]: Type[Key];
        }>;
    }[keyof Type]>>;
}

declare namespace $ {
    /**
     * Get value type by flat key name.
     *
     * 	// number
     * 	type abc_type = $mol_type_volume_value< { a: { b: { c: number }; d: string }, 'a.b.c' } >
     */
    type $mol_type_volume_value<Type, Key extends string> = $mol_type_access<Type, Key> extends never ? Key extends `${infer Left}.${infer Right}` ? $mol_type_access<Type, Left> extends never ? never : $mol_type_volume_value<$mol_type_access<Type, Left>, Right> : never : $mol_type_access<Type, Key>;
}

declare namespace $ {
    /**
     * Make flat structure from volume. Camel case is used for key names.
     *
     * 	// { fooBarWee: number; fooToo: string }
     * 	type flat = $mol_type_flat_camel< { foo: { bar: { wee: number }; too: string } } >
     */
    type $mol_type_flat_camel<Type, Endpoint = never> = $mol_type_partial_undefined<{
        [FlatKeys in $mol_type_flat_keys<Type, Endpoint> as $mol_type_case_camel<FlatKeys>]: $mol_type_volume_value<Type, $mol_type_case_dot<FlatKeys>>;
    }>;
}

declare namespace $ {
    /**
     * Returns last element of `Tuple`.
     *
     * 	$mol_type_tail<[ 1 , 2 , 3 ]> // 3
     */
    type $mol_type_foot<Tuple extends readonly any[]> = Tuple['length'] extends 0 ? never : Tuple[$mol_type_tail<Tuple>['length']];
}

declare namespace $ {
    /**
     * Overwrite `Tuple` first element.
     *
     * 	// [ 'd', 'b', 'c' ]
     * 	$mol_type_head_write< [ 'a', 'b', 'c' ], 'd' >
     */
    type $mol_type_head_write<Tuple extends Array<any>, Over> = [
        Over,
        ...$mol_type_tail<Tuple>
    ];
}

declare namespace $ {
    /**
     * Recursive `Readonly`.
     *
     * 	let props : $mol_type_immutable_deep< { foo: number[] } > = { readonly foo: readonly number[] }
     */
    type $mol_type_immutable_deep<Val> = {
        readonly [field in keyof Val]: $mol_type_immutable_deep<Val[field]>;
    };
}

declare namespace $ {
    type Parse<Str extends string, Res extends Int = Zero> = Str extends `${infer Letter extends keyof Digits}${infer Tail}` ? Parse<Tail, Plus<[
        Mult<[Res, Ten]>,
        Digit<Letter>
    ]>> : Res;
    type Check<Value> = Parse<`${Extract<Value, number | string>}`> extends never ? $mol_type_error<'Is not Int'> : number | string;
    type Digits = {
        '0': 0;
        '1': 1;
        '2': 2;
        '3': 3;
        '4': 4;
        '5': 5;
        '6': 6;
        '7': 7;
        '8': 8;
        '9': 9;
    };
    type Digit<Letter extends string> = Up<Digits[Extract<Letter, keyof Digits>]>;
    type Int = unknown[];
    type Pair = [Int, Int];
    type Zero = [];
    type One = [0];
    type Ten = Up<10>;
    type Down<Value extends Int> = Value["length"];
    type Up<Value extends number, Res extends Int = Zero> = Value extends Down<Res> ? Res : Up<Value, Next<Res>>;
    type Next<Value extends Int> = Plus<[Value, One]>;
    type Prev<Value extends Int> = Minus<[Value, One]>;
    /** Number literal which is sum of two another */
    export type $mol_type_int_plus<Left extends Check<Left>, Right extends Check<Right>> = Down<Plus<[
        Parse<`${Left}`>,
        Parse<`${Right}`>
    ]>>;
    type Plus<Arg extends Pair> = [...Arg[0], ...Arg[1]];
    /** Number literal which is subtract of two another */
    export type $mol_type_int_minus<Left extends Check<Left>, Right extends Check<Right>> = Down<Minus<[
        Parse<`${Left}`>,
        Parse<`${Right}`>
    ]>>;
    type Minus<Arg extends Pair> = Arg[0] extends [...Arg[1], ...infer Res] ? Extract<Res, Int> : never;
    /** Number literal which is multiply of two another */
    export type $mol_type_int_mult<Left extends Check<Left>, Right extends Check<Right>> = Down<Mult<[
        Parse<`${Left}`>,
        Parse<`${Right}`>
    ]>>;
    type Mult<Arg extends Pair, Res extends Int = Zero> = Arg[1] extends Zero ? Res : Mult<[
        Arg[0],
        Prev<Arg[1]>
    ], Plus<[Res, Arg[0]]>>;
    /** Number literal which is power one to another */
    export type $mol_type_int_pow<Left extends Check<Left>, Right extends Check<Right>> = Down<Pow<[
        Parse<`${Left}`>,
        Parse<`${Right}`>
    ]>>;
    type Pow<Arg extends Pair, Res extends Int = One> = Arg[1] extends Zero ? Res : Pow<[
        Arg[0],
        Prev<Arg[1]>
    ], Mult<[Res, Arg[0]]>>;
    /**
     * Range of number literals from Lo up to Hi
     * **Slow on large ranges**
     */
    export type $mol_type_int_range<Lo extends Check<Lo>, Hi extends Check<Hi>> = Down<Range<[
        Parse<`${Lo}`>,
        Parse<`${Hi}`>
    ]>>;
    type Range<Args extends Pair> = keyof Args[0] extends keyof Args[1] ? Plus<[
        Args[0],
        Parse<Exclude<keyof Minus<[Args[1], Args[0]]>, symbol | number>>
    ]> : never;
    /** Unknown when number literals is ordered */
    export type $mol_type_int_ordered<Left extends Check<Left>, Right extends Check<Right>> = keyof Parse<`${Left}`> extends keyof Parse<`${Right}`> ? unknown : never;
    type Calc<Expr extends string> = Expr extends `${infer Left}(${infer Inner})${infer Right}` ? Calc<`${Left}${Down<Calc<Inner>>}${Right}`> : Expr extends `${infer Left}..${infer Right}` ? Range<[Calc<Left>, Calc<Right>]> : Expr extends `${infer Left}+${infer Right}` ? Plus<[Calc<Left>, Calc<Right>]> : Expr extends `${infer Left}-${infer Right}` ? Minus<[Calc<Left>, Calc<Right>]> : Expr extends `${infer Left}*${infer Right}` ? Mult<[Calc<Left>, Calc<Right>]> : Expr extends `${infer Left}^${infer Right}` ? Pow<[Calc<Left>, Calc<Right>]> : Expr extends `${infer Left} ` ? Calc<Left> : Expr extends ` ${infer Right}` ? Calc<Right> : Parse<Expr>;
    /** Evaluates simple expression */
    export type $mol_type_int_calc<Expr extends string> = Down<Calc<Expr>>;
    export {};
}

declare namespace $ {
    /**
     * All keys from union type
     *
     * 	type keys_all = $mol_type_keys_all< { a: number } | { b: string } > // 'a' | 'b'
     */
    type $mol_type_keys_all<Type> = Type extends Type ? keyof Type : never;
}

declare namespace $ {
    /**
     * Extracts keys from `Input` which values extends `Upper` and extendable by `Lower`.
     *
     * 	type MathConstants = $mol_type_keys_extract< Math , number > // "E" | "PI" ...
     */
    type $mol_type_keys_extract<Input, Upper, Lower = never> = {
        [Field in keyof Input]: unknown extends Input[Field] ? never : Input[Field] extends never ? never : Input[Field] extends Upper ? [
            Lower
        ] extends [Input[Field]] ? Field : never : never;
    }[keyof Input];
}

declare namespace $ {
    /**
     * Exclude keys from `Input` which values extends `Upper`.
     *
     * 	type MathConstants = $mol_type_keys_exclude< Math , Function > // "E" | "PI" ...
     */
    type $mol_type_keys_exclude<Input, Upper> = Exclude<keyof Input, $mol_type_keys_extract<Input, Upper>>;
}

declare namespace $ {
    /**
     * Recursive `-Readonly`.
     *
     * 	let props : $mol_type_mutable< { readonly foo: number[] } > = { foo: number[] }
     */
    type $mol_type_mutable_deep<Val> = {
        -readonly [field in keyof Val]: $mol_type_mutable_deep<Val[field]>;
    };
}

declare namespace $ {
    /**
     * Null union with properties or with type itself.
     *
     * 	// { foo: number | null; bar: string | null }
     * 	$mol_type_nullable< { foo: number; bar: string } >
     */
    type $mol_type_nullable<Type> = Type extends object ? {
        [Key in keyof Type]: Type[Key] | null;
    } : Type | null;
}

declare namespace $ {
    /**
     * Omit keys from `Input` which values extends `Upper`.
     *
     * 	type MathConstants = $mol_type_omit< Math , Function > // { E , PI , ... }
     */
    type $mol_type_omit<Input, Upper> = Pick<Input, $mol_type_keys_exclude<Input, Upper>>;
}

declare namespace $ {
    /**
     * Returns type of function param by index.
     *
     * 	// 888
     * 	$mol_type_param< ( a : 777 , b : 888 )=> 666 , 1 >
     */
    type $mol_type_param<Func, Index extends number> = Func extends (...params: infer Params) => any ? Params[Index] : Func extends new (...params: infer Params2) => any ? Params2[Index] : never;
}

declare namespace $ {
    /**
     * Recursive `Partial`.
     *
     * 	let props : $mol_type_partial_deep< HTMLElement > = { style : { display : 'block' } }
     */
    type $mol_type_partial_deep<Val> = Val extends object ? Val extends Function ? Val : {
        [field in keyof Val]?: $mol_type_partial_deep<Val[field]> | undefined;
    } : Val;
}

declare namespace $ {
    /**
     * Picks keys from `Input` which values extends `Upper`.
     *
     * 	type MathConstants = $mol_type_pick< Math , number > // { E , PI , ... }
     */
    type $mol_type_pick<Input, Upper> = Pick<Input, $mol_type_keys_extract<Input, Upper>>;
}

declare namespace $ {
    /**
     * Recursive `Required`.
     *
     * 	type req = $mol_type_required_deep< { a?: { b?: number } } > // { a: { b: number } }
     */
    type $mol_type_required_deep<Type> = Type extends object ? Type extends Function ? Exclude<Type, undefined> : {
        [Key in keyof Type]-?: $mol_type_required_deep<Type[Key]>;
    } : Exclude<Type, undefined>;
}

declare namespace $ {
    /**
     * Returns type of function result or class instance.
     *
     * 	// 777
     * 	$mol_type_result< ()=> 777 >
     *
     * 	// 777
     * 	$mol_type_result< new()=> 777 >
     */
    type $mol_type_result<Func> = Func extends (...params: any) => infer Result ? Result : Func extends new (...params: any) => infer Result ? Result : never;
}

declare namespace $ {
    /**
     * Returns reversed tuple.
     *
     * 	$mol_type_reverse< [ 1, 2, 3 ] > // [ 3, 2, 1 ]
     */
    type $mol_type_reverse<Tuple extends readonly any[], Reversed extends readonly any[] = []> = {
        0: Reversed;
        1: $mol_type_reverse<$mol_type_tail<Tuple>, [
            $mol_type_head<Tuple>,
            ...Reversed
        ]>;
    }[Tuple['length'] extends 0 ? 0 : 1];
}

declare namespace $ {
    /** Any unary function **/
    type $mol_type_unary_func = ((param: any) => any);
    type $mol_type_unary_class = new (param: any) => any;
    type $mol_type_unary = $mol_type_unary_func | $mol_type_unary_class;
}

declare namespace $ {
    type $mol_type_writable<T> = {
        -readonly [P in keyof T]: T[P];
    };
}

export = $;
//# sourceMappingURL=node.d.ts.map