mol_type_all 0.0.1828 → 0.0.1829

package/README.md

@@ -2,18 +2,18 @@
 
 Collection of TypeScript meta types for complex logic.
 
-![Type Asserts](https://i.imgur.com/CNI5KvX.png)
+# Usage
 
-# MAM Usage
+## MAM
 
 ```typescript
-type first_of_tuple = $mol_type_assert<
-	$mol_type_head<[ 1 , 2 , 3 ]> ,
-	1
+type cutted_head = $mol_type_assert<
+	$mol_type_tail<[ 1, 2, 3 ]>,
+	[ 2, 3 ]
 >
 ```
 
-# NPM usage
+## NPM
 
 ```sh
 npm install mol_type_all
@@ -21,17 +21,87 @@ npm install mol_type_all
 
 ```typescript
 import {
-	$mol_type_assert as Assert ,
-	$mol_type_head as Head ,
+	$mol_type_assert as Assert,
+	$mol_type_tail as Tail,
 } from 'mol_type_all'
 
-type first_of_tuple = Assert<
-	Head<[ 1 , 2 , 3 ]> ,
-	1
+type cutted_head = Assert<
+	Tail<[ 1, 2, 3 ]>,
+	[ 2, 3 ]
 >
 ```
 
-[![Edit $mol_type example](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/s/moltype-example-1ebxp)
+# Utilite types
+
+## Assertions
+
+- [$mol_type_error](./error) - special type for errors with details.
+- [$mol_type_assert](./assert) - fails type check on type inequality.
+- [$mol_type_enforce](./enforce) - fails type check on type incompatibility.
+
+```ts
+// Actual result
+type partial_record = $mol_type_assert<
+	Partial<{ foo: 123 }>, // Some expression
+	{ foo?: 123 } // Expected result
+>
+```
+
+![Type Asserts](https://habrastorage.org/webt/a4/d3/d6/a4d3d643f36e4ac3f431b9dac7a1f2c5.png)
+
+## Tuples
+
+- [$mol_type_head](./head) - first item of tuple or never.
+- [$mol_type_head_write](./head/write) - replaces first element of tuple.
+- [$mol_type_tail](./tail) - tuple without first item.
+- [$mol_type_foot](./foot) - last item of tuple or never.
+- [$mol_type_reverse](./reverse) - makes reversed tuple.
+
+## Algebraics
+
+- [$mol_type_equals](./equals) - check for types equality.
+- [$mol_type_access](./access) - takes type of property from wild union type.
+- [$mol_type_filter_keys](./filter/keys) - records from union with provided property.
+- [$mol_type_intersect](./intersect) - converts union to intersection.
+- [$mol_type_merge](./merge) - merges intersection of records to one record.
+- [$mol_type_keys_all](./keys/all) - all keys from all records from union.
+
+## Strings
+
+- [$mol_type_alphabet_*](./alphabet) - character classes.
+- [$mol_type_string_split](./string/split) - splits string by separator.
+- [$mol_type_string_join](./string/join) - joins strings by separator.
+
+## Numbers
+
+- [$mol_type_int_*](./int) - integer arithmetic (`+`, `-`, `*`, `/`, `^`, `..`, `()`, `<`)
+
+## Functions
+
+- [$mol_type_unary](./unary) - function/class with single param.
+- [$mol_type_param](./param) - takes param type by index.
+- [$mol_type_result](./result) - takes result/instance type.
+
+## Records
+
+- [$mol_type_immutable_deep](./immutable/deep) - recursive immutability.
+- [$mol_type_mutable_deep](./mutable/deep) - recursive mutability.
+- [$mol_type_partial_undefined](./partial/undefined) - makes all properties partial.
+- [$mol_type_partial_deep](./partial/deep) - makes all properties partial deeply.
+- [$mol_type_required_deep](./required/deep) - makes all properties required deeply.
+- [$mol_type_nullable](./nullable) - makes all properties nullable.
+- [$mol_type_writable](./writable) - makes all properties writable.
+- [$mol_type_keys_extract](./keys/extract) - extracts key names from record by value type.
+- [$mol_type_keys_exclude](./keys/exclude) - excludes key names from record by value type.
+- [$mol_type_omit](./omit) - omits properties by value type.
+- [$mol_type_pick](./pick) - pick properties by value type.
+- [$mol_type_override](./override) - fully replaces properties.
+- [$mol_type_case_*](./case) - converts keys/values to upper/lower/capital cases.
+
+- [$mol_type_flat_camel](./flat/camel) - makes flat record from volume records tree.
+- [$mol_type_flat_keys](./flat/keys) - takes keys paths from volume records tree.
+- [$mol_type_volume](./volume) - makes volume records tree from flat record.
+- [$mol_type_volume_value](./volume/value) - takes value from volume records tree by path.
 
 # Similar Projects
 

package/node.d.ts

@@ -14,6 +14,46 @@ declare namespace $ {
     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.
@@ -25,6 +65,7 @@ declare namespace $ {
 }
 
 declare namespace $ {
+    /** Returns error type, that don't match to normal value. */
     type $mol_type_error<Message, Info = {}> = Message & {
         $mol_type_error: Info;
     };
@@ -47,6 +88,142 @@ declare namespace $ {
     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 ? unknown 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> = $mol_type_merge<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.
@@ -58,11 +235,28 @@ declare namespace $ {
 
 declare namespace $ {
     /**
-     * Returns `Tuple` pushed by `Item`.
+     * 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.
      *
-     * 	$mol_type_tail< [ 1 , 2 ] , 3 > // [ 1 , 2 , 3 ]
+     * 	// [ 'foo', 'bar', 'wee' ]
+     * 	$mol_type_string_split< 'foo-bar-wee', '-' >
      */
-    type $mol_type_append<Tuple extends readonly any[], Item extends any> = [...Tuple, Item];
+    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 $ {
@@ -74,6 +268,198 @@ declare namespace $ {
     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]>,
@@ -154,11 +540,11 @@ declare namespace $ {
 
 declare namespace $ {
     /**
-     * Converts union of types to intersection of same types
+     * All keys from union type
      *
-     * 	$mol_type_intersect< number | string > // number & string
+     * 	type keys_all = $mol_type_keys_all< { a: number } | { b: string } > // 'a' | 'b'
      */
-    type $mol_type_intersect<Union> = (Union extends any ? (_: Union) => void : never) extends ((_: infer Intersection) => void) ? Intersection : never;
+    type $mol_type_keys_all<Type> = Type extends Type ? keyof Type : never;
 }
 
 declare namespace $ {
@@ -185,25 +571,25 @@ declare namespace $ {
 
 declare namespace $ {
     /**
-     * Reqursive converts intersection of records to record of intersections
+     * Recursive `-Readonly`.
      *
-     * 	// { a : { x : 1 , y : 2 } }
-     * 	$mol_type_merge< { a : { x : 1 } }&{ a : { y : 2 } } >
+     * 	let props : $mol_type_mutable< { readonly foo: number[] } > = { foo: number[] }
      */
-    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 ? unknown extends $mol_type_equals<{
-        [Key in keyof Intersection]: Intersection[Key];
-    }, Intersection> ? Intersection : {
-        [Key in keyof Intersection]: $mol_type_merge<Intersection[Key]>;
-    } : Intersection : Intersection;
+    type $mol_type_mutable_deep<Val> = {
+        -readonly [field in keyof Val]: $mol_type_mutable_deep<Val[field]>;
+    };
+}
+
+declare namespace $ {
     /**
-     * Flat converts intersection of records to record of intersections
+     * Null union with properties or with type itself.
      *
-     * 	// { a: 1, b: 2 }
-     * 	$mol_type_merge< { a: 1 } & { b: 2 } >
+     * 	// { foo: number | null; bar: string | null }
+     * 	$mol_type_nullable< { foo: number; bar: string } >
      */
-    type $mol_type_merge_object<Intersection> = {
-        [Key in keyof Intersection]: Intersection[Key];
-    };
+    type $mol_type_nullable<Type> = Type extends object ? {
+        [Key in keyof Type]: Type[Key] | null;
+    } : Type | null;
 }
 
 declare namespace $ {
@@ -236,21 +622,6 @@ declare namespace $ {
     } : Val;
 }
 
-declare namespace $ {
-    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 $ {
     /**
      * Picks keys from `Input` which values extends `Upper`.
@@ -262,11 +633,13 @@ declare namespace $ {
 
 declare namespace $ {
     /**
-     * Returns `Tuple` unshifted by `Item`.
+     * Recursive `Required`.
      *
-     * 	$mol_type_tail< 1 , [ 2 , 3 ] > // [ 1 , 2 , 3 ]
+     * 	type req = $mol_type_required_deep< { a?: { b?: number } } > // { a: { b: number } }
      */
-    type $mol_type_prepend<Item extends any, Tuple extends readonly any[]> = ((head: Item, ...args: Tuple) => any) extends ((...args: infer Result) => any) ? Result : never;
+    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 $ {
@@ -284,13 +657,16 @@ declare namespace $ {
 
 declare namespace $ {
     /**
-     * Returns reversed `Tuple`.
+     * Returns reversed tuple.
      *
-     * 	$mol_type_reverse< [ 1 , 2 ,3 ] > // [ 3 , 2 , 1 ]
+     * 	$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_prepend<$mol_type_head<Tuple>, Reversed>>;
+        1: $mol_type_reverse<$mol_type_tail<Tuple>, [
+            $mol_type_head<Tuple>,
+            ...Reversed
+        ]>;
     }[Tuple['length'] extends 0 ? 0 : 1];
 }
 
@@ -301,5 +677,11 @@ declare namespace $ {
     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