mol_schema 0.0.22 → 0.0.24

package/node.test.js

@@ -72,34 +72,36 @@ var $;
         static toString() {
             return $$.$mol_func_name(this);
         }
-        /** Type-guard that checks value by schema. */
-        static check(val) {
+        /** Type-predicate that checks value by schema. */
+        static check(value) {
             try {
-                this.guard(val);
+                this.guard(value);
                 return true;
             }
             catch (error) {
                 return false;
             }
         }
-        static [Symbol.hasInstance](val) {
-            return this.check(val);
+        /** `instanceof` support */
+        static [Symbol.hasInstance](value) {
+            return this.check(value);
         }
-        /** Strict parse. Fails of wrong values. */
+        /** Type-parser that fails of wrong values. */
         static guard(value) {
             return value;
         }
-        /** Relaxed cast. Normalizes wrong values. */
+        /** Type-caster that normalizes wrong values. */
         static cast(value) {
             try {
-                return this.guard(value);
+                this.guard(value);
+                return value;
             }
             catch (error) {
                 return this.default;
             }
         }
         /** Default value which conforms schema. */
-        static default = undefined;
+        static default = null;
     }
     $.$mol_schema_any = $mol_schema_any;
 })($ || ($ = {}));
@@ -201,6 +203,241 @@ var $;
     $.$mol_schema_string = $mol_schema_string;
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_ambient_ref = Symbol('$mol_ambient_ref');
+    function $mol_ambient(overrides) {
+        return Object.setPrototypeOf(overrides, this || $);
+    }
+    $.$mol_ambient = $mol_ambient;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    const instances = new WeakSet();
+    /**
+     * Proxy that delegates all to lazy returned target.
+     *
+     * 	$mol_delegate( Array.prototype , ()=> fetch_array() )
+     */
+    function $mol_delegate(proto, target) {
+        const proxy = new Proxy(proto, {
+            get: (_, field) => {
+                const obj = target();
+                let val = Reflect.get(obj, field);
+                if (typeof val === 'function') {
+                    val = val.bind(obj);
+                }
+                return val;
+            },
+            has: (_, field) => Reflect.has(target(), field),
+            set: (_, field, value) => Reflect.set(target(), field, value),
+            getOwnPropertyDescriptor: (_, field) => Reflect.getOwnPropertyDescriptor(target(), field),
+            ownKeys: () => Reflect.ownKeys(target()),
+            getPrototypeOf: () => Reflect.getPrototypeOf(target()),
+            setPrototypeOf: (_, donor) => Reflect.setPrototypeOf(target(), donor),
+            isExtensible: () => Reflect.isExtensible(target()),
+            preventExtensions: () => Reflect.preventExtensions(target()),
+            apply: (_, self, args) => Reflect.apply(target(), self, args),
+            construct: (_, args, retarget) => Reflect.construct(target(), args, retarget),
+            defineProperty: (_, field, descr) => Reflect.defineProperty(target(), field, descr),
+            deleteProperty: (_, field) => Reflect.deleteProperty(target(), field),
+        });
+        instances.add(proxy);
+        return proxy;
+    }
+    $.$mol_delegate = $mol_delegate;
+    Reflect.defineProperty($mol_delegate, Symbol.hasInstance, {
+        value: (obj) => instances.has(obj),
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_owning_map = new WeakMap();
+    function $mol_owning_allow(having) {
+        try {
+            if (!having)
+                return false;
+            if (typeof having !== 'object' && typeof having !== 'function')
+                return false;
+            if (having instanceof $mol_delegate)
+                return false;
+            if (typeof having['destructor'] !== 'function')
+                return false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    $.$mol_owning_allow = $mol_owning_allow;
+    function $mol_owning_get(having, Owner) {
+        if (!$mol_owning_allow(having))
+            return null;
+        while (true) {
+            const owner = $.$mol_owning_map.get(having);
+            if (!owner)
+                return owner;
+            if (!Owner)
+                return owner;
+            if (owner instanceof Owner)
+                return owner;
+            having = owner;
+        }
+    }
+    $.$mol_owning_get = $mol_owning_get;
+    function $mol_owning_check(owner, having) {
+        if (!$mol_owning_allow(having))
+            return false;
+        if ($.$mol_owning_map.get(having) !== owner)
+            return false;
+        return true;
+    }
+    $.$mol_owning_check = $mol_owning_check;
+    function $mol_owning_catch(owner, having) {
+        if (!$mol_owning_allow(having))
+            return false;
+        if ($.$mol_owning_map.get(having))
+            return false;
+        $.$mol_owning_map.set(having, owner);
+        return true;
+    }
+    $.$mol_owning_catch = $mol_owning_catch;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    function $mol_fail_hidden(error) {
+        throw error; /// Use 'Never Pause Here' breakpoint in DevTools or simply blackbox this script
+    }
+    $.$mol_fail_hidden = $mol_fail_hidden;
+})($ || ($ = {}));
+
+;
+"use strict";
+
+;
+"use strict";
+var $;
+(function ($) {
+    if (!Symbol.dispose)
+        Symbol.dispose = Symbol('Symbol.dispose');
+    class $mol_object2 {
+        static $ = $;
+        [Symbol.toStringTag];
+        [$mol_ambient_ref] = null;
+        get $() {
+            if (this[$mol_ambient_ref])
+                return this[$mol_ambient_ref];
+            const owner = $mol_owning_get(this);
+            return this[$mol_ambient_ref] = owner?.$ || this.constructor.$ || $mol_object2.$;
+        }
+        set $(next) {
+            if (this[$mol_ambient_ref])
+                $mol_fail_hidden(new Error('Context already defined'));
+            this[$mol_ambient_ref] = next;
+        }
+        static create(init) {
+            const obj = new this;
+            if (init)
+                init(obj);
+            return obj;
+        }
+        static [Symbol.toPrimitive]() {
+            return this.toString();
+        }
+        static toString() {
+            return this[Symbol.toStringTag] || this.$.$mol_func_name(this);
+        }
+        static toJSON() {
+            return this.toString();
+        }
+        static [$mol_key_handle]() {
+            return this.toString();
+        }
+        destructor() { }
+        static destructor() { }
+        [Symbol.dispose]() {
+            this.destructor();
+        }
+        //[ Symbol.toPrimitive ]( hint: string ) {
+        //	return hint === 'number' ? this.valueOf() : this.toString()
+        //}
+        toString() {
+            return this[Symbol.toStringTag] || this.constructor.name + '<>';
+        }
+    }
+    $.$mol_object2 = $mol_object2;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_wrapper extends $mol_object2 {
+        static wrap;
+        static run(task) {
+            return this.func(task)();
+        }
+        static func(func) {
+            return this.wrap(func);
+        }
+        static get class() {
+            return (Class) => {
+                const construct = (target, args) => new Class(...args);
+                const handler = {
+                    construct: this.func(construct)
+                };
+                handler[Symbol.toStringTag] = Class.name + '#';
+                return new Proxy(Class, handler);
+            };
+        }
+        static get method() {
+            return (obj, name, descr = Reflect.getOwnPropertyDescriptor(obj, name)) => {
+                descr.value = this.func(descr.value);
+                return descr;
+            };
+        }
+        static get field() {
+            return (obj, name, descr = Reflect.getOwnPropertyDescriptor(obj, name)) => {
+                descr.get = descr.set = this.func(descr.get);
+                return descr;
+            };
+        }
+    }
+    $.$mol_wrapper = $mol_wrapper;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_memo extends $mol_wrapper {
+        static wrap(task) {
+            const store = new WeakMap();
+            const fun = function (next) {
+                if (next === undefined && store.has(this ?? fun))
+                    return store.get(this ?? fun);
+                const val = task.call(this, next) ?? next;
+                store.set(this ?? fun, val);
+                return val;
+            };
+            Reflect.defineProperty(fun, 'name', { value: task.name + ' ' });
+            return fun;
+        }
+    }
+    $.$mol_memo = $mol_memo;
+})($ || ($ = {}));
+
 ;
 "use strict";
 var $;
@@ -274,7 +511,32 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_pattern(Pattern) {
+    class $mol_memo_key extends $mol_wrapper {
+        static wrap(task) {
+            const store = new WeakMap();
+            const fun = function (key, next) {
+                let store2 = store.get(this ?? fun);
+                if (!store2)
+                    store.set(this ?? fun, store2 = new Map);
+                const key_str = $mol_key(key);
+                if (next === undefined && store2.has(key_str))
+                    return store2.get(key_str);
+                const val = task.call(this, key, next) ?? next;
+                store2.set(key_str, val);
+                return val;
+            };
+            Reflect.defineProperty(fun, 'name', { value: task.name + ' ' });
+            return fun;
+        }
+    }
+    $.$mol_memo_key = $mol_memo_key;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_schema_pattern = $mol_memo_key.func(function $mol_schema_pattern(Pattern) {
         return class $mol_schema_pattern_ extends $mol_schema_string {
             static Pattern = Pattern;
             static toString() {
@@ -292,15 +554,14 @@ var $;
             }
             static default = '';
         };
-    }
-    $.$mol_schema_pattern = $mol_schema_pattern;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_instance(Class, ...args) {
+    $.$mol_schema_instance = $mol_memo_key.func(function $mol_schema_instance(Class) {
         class $mol_schema_instance_ extends $mol_schema_any {
             static Class = Class;
             static toString() {
@@ -313,108 +574,129 @@ var $;
                     return value;
                 return $mol_fail(new TypeError('Wrong class', { cause: { value, schema: this } }));
             }
-            static default = new Class(...args);
+            static cast(value) {
+                return this.guard(value);
+            }
+            static default;
         }
-        return ((Class[Symbol.hasInstance] === $mol_schema_any[Symbol.hasInstance])
+        return ((Class?.[Symbol.hasInstance] === $mol_schema_any[Symbol.hasInstance])
             ? Class
             : $mol_schema_instance_);
-    }
-    $.$mol_schema_instance = $mol_schema_instance;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
+var $;
+(function ($) {
+    function $mol_schema_lazy(Schema) {
+        // return $mol_delegate( $mol_schema_any, Schema )
+        return class $mol_schema_lazy_ extends $mol_schema_any {
+            static Schema = $mol_memo.func(Schema);
+            static guard(value) {
+                return this.Schema().guard(value);
+            }
+            static cast(value) {
+                return this.Schema().cast(value);
+            }
+            static get default() {
+                return this.Schema().default;
+            }
+        };
+    }
+    $.$mol_schema_lazy = $mol_schema_lazy;
+})($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_every(Schemas) {
-        return class $mol_schema_every_ extends $mol_schema_any {
-            static Schemas = Schemas;
+    $.$mol_schema_some = $mol_memo_key.func(function $mol_schema_some(Variants) {
+        return class $mol_schema_some_ extends $mol_schema_any {
+            static Variants = Variants;
             static toString() {
-                if (this !== $mol_schema_every_)
+                if (this !== $mol_schema_some_)
                     return super.toString();
-                return '$mol_schema_every<' + $mol_key(Schemas) + '>';
+                return '$mol_schema_some<' + $mol_key(Variants) + '>';
             }
             static guard(value) {
-                for (const Schema of Schemas) {
-                    Schema.guard(value);
+                const errors = [];
+                for (const Variant of Variants) {
+                    try {
+                        return Variant.guard(value);
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
                 }
-                return value;
+                return $mol_fail(new AggregateError(errors, 'Wrong variant', { cause: { value, schema: this } }));
             }
             static cast(value) {
-                for (const Scheme of Schemas)
-                    value = Scheme.cast(value);
-                return value;
+                try {
+                    return this.guard(value);
+                }
+                catch (error) {
+                    return Variants[0].cast(value);
+                }
             }
-            static default = Schemas.find(Scheme => this.check(Scheme.default));
+            static default = Variants[0].default;
         };
-    }
-    $.$mol_schema_every = $mol_schema_every;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_range(Min, Max) {
-        return class $mol_schema_range_ extends $mol_schema_any {
-            static Min = Min;
-            static Max = Max;
+    $.$mol_schema_dict = $mol_memo_key.func(function $mol_schema_dict(Pair) {
+        return class $mol_schema_dict_ extends $mol_schema_any {
+            static Pair = Pair;
             static toString() {
-                if (this !== $mol_schema_range_)
+                if (this !== $mol_schema_dict_)
                     return super.toString();
-                return '$mol_schema_range<' + $mol_key(Min) + ',' + $mol_key(Max) + '>';
+                return '$mol_schema_dict<' + $mol_key(Pair) + '>';
             }
             static guard(value) {
-                if (typeof value !== 'number' && typeof value !== 'bigint')
-                    return $mol_fail(new TypeError('Uncomparable type', { cause: { value, schema: this } }));
-                if (!(value <= Max))
-                    return $mol_fail(new TypeError('Too large', { cause: { value, schema: this } }));
-                if (!(value >= Min))
-                    return $mol_fail(new TypeError('Too small', { cause: { value, schema: this } }));
+                if (Object.getPrototypeOf(Object.getPrototypeOf(value))) {
+                    return $mol_fail(new TypeError('Non dictionary', { cause: { value, schema: this } }));
+                }
+                for (const key in value) {
+                    try {
+                        Pair[0].guard(key);
+                    }
+                    catch (error) {
+                        return $mol_fail(new TypeError('Wrong key', { cause: { key, error, value, schema: this } }));
+                    }
+                    try {
+                        Pair[1].guard(value[key]);
+                    }
+                    catch (error) {
+                        return $mol_fail(new TypeError('Wrong val', { cause: { key, error, value, schema: this } }));
+                    }
+                }
                 return value;
             }
-            static cast(val) {
-                if (val > Max)
-                    return Max;
-                if (val >= Min)
-                    return val;
-                return Min;
+            static cast(value) {
+                if (Object.getPrototypeOf(Object.getPrototypeOf(value)))
+                    return this.default;
+                const res = {};
+                for (const key in value) {
+                    if (!Pair[0].check(key))
+                        continue;
+                    res[key] = Pair[1].cast(value[key]);
+                }
+                return res;
             }
-            static default = Min;
+            static default = {};
         };
-    }
-    $.$mol_schema_range = $mol_schema_range;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    class $mol_schema_positive extends $mol_schema_range(0, Number.POSITIVE_INFINITY) {
-    }
-    $.$mol_schema_positive = $mol_schema_positive;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    class $mol_schema_natural extends $mol_schema_every([
-        $mol_schema_integer,
-        $mol_schema_positive,
-    ]) {
-    }
-    $.$mol_schema_natural = $mol_schema_natural;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_enum(Options) {
+    $.$mol_schema_enum = $mol_memo_key.func(function $mol_schema_enum(Options) {
         return class $mol_schema_enum_ extends $mol_schema_any {
             static Options = Options;
             static toString() {
@@ -425,174 +707,188 @@ var $;
             static guard(value) {
                 if (Options.some(Option => Object.is(Option, value)))
                     return value;
-                return $mol_fail(new TypeError('No one option', { cause: { value, schema: this } }));
+                return $mol_fail(new TypeError('Wrong option', { cause: { value, schema: this } }));
             }
-            static cast(val) {
-                if (this.check(val))
-                    return val;
+            static cast(value) {
+                if (this.check(value))
+                    return value;
                 return Options[0];
             }
             static default = Options[0];
         };
-    }
-    $.$mol_schema_enum = $mol_schema_enum;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    class $mol_schema_negative extends $mol_schema_range(Number.NEGATIVE_INFINITY, 0) {
-    }
-    $.$mol_schema_negative = $mol_schema_negative;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_some(Variants) {
-        return class $mol_schema_some_ extends $mol_schema_any {
-            static Variants = Variants;
+    $.$mol_schema_list = $mol_memo_key.func(function $mol_schema_list(Item) {
+        return class $mol_schema_list_ extends $mol_schema_any {
+            static Item = Item;
             static toString() {
-                if (this !== $mol_schema_some_)
+                if (this !== $mol_schema_list_)
                     return super.toString();
-                return '$mol_schema_some<' + $mol_key(Variants) + '>';
+                return '$mol_schema_list<' + $mol_key(Item) + '>';
             }
             static guard(value) {
-                const errors = [];
-                for (const Variant of Variants) {
+                if (!Array.isArray(value))
+                    return $mol_fail(new TypeError('Non array', { cause: { value, schema: this } }));
+                for (const [index, item] of super.guard(value).entries()) {
                     try {
-                        return Variant.guard(value);
+                        Item.guard(item);
                     }
                     catch (error) {
-                        errors.push(error);
+                        return $mol_fail(new TypeError('Wrong item', { cause: { index, error, value, schema: this } }));
                     }
                 }
-                return $mol_fail(new AggregateError(errors, 'No one variant', { cause: { value, schema: this } }));
+                return value;
             }
             static cast(value) {
-                try {
-                    return this.guard(value);
-                }
-                catch (error) {
-                    return Variants[0].cast(value);
-                }
+                if (!Array.isArray(value))
+                    return this.default;
+                return value.map(item => Item.cast(item));
             }
-            static default = Variants[0].default;
+            static default = [];
         };
-    }
-    $.$mol_schema_some = $mol_schema_some;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_maybe(Some) {
-        return class $mol_schema_maybe_ extends $mol_schema_some([$mol_schema_enum([undefined, null]), Some]) {
-            static Some = Some;
-            static toString() {
-                if (this !== $mol_schema_maybe_)
-                    return super.toString();
-                return '$mol_schema_maybe<' + $mol_key(Some) + '>';
-            }
-        };
+    class $mol_schema_json extends $mol_schema_lazy(() => $mol_schema_some([
+        $mol_schema_dict([$mol_schema_string, $mol_schema_json]),
+        $mol_schema_enum([null]),
+        $mol_schema_boolean, $mol_schema_float, $mol_schema_string,
+        $mol_schema_list($mol_schema_json),
+    ])) {
     }
-    $.$mol_schema_maybe = $mol_schema_maybe;
+    $.$mol_schema_json = $mol_schema_json;
 })($ || ($ = {}));
 
+;
+"use strict";
+
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_list(Item) {
-        return class $mol_schema_list_ extends $mol_schema_any {
-            static Item = Item;
+    $.$mol_schema_every = $mol_memo_key.func(function $mol_schema_every(Schemas) {
+        return class $mol_schema_every_ extends $mol_schema_any {
+            static Schemas = Schemas;
             static toString() {
-                if (this !== $mol_schema_list_)
+                if (this !== $mol_schema_every_)
                     return super.toString();
-                return '$mol_schema_list<' + $mol_key(Item) + '>';
+                return '$mol_schema_every<' + $mol_key(Schemas) + '>';
             }
             static guard(value) {
-                if (!Array.isArray(value))
-                    return $mol_fail(new TypeError('Non array', { cause: { value, schema: this } }));
-                for (const [index, item] of super.guard(value).entries()) {
-                    try {
-                        Item.guard(item);
-                    }
-                    catch (error) {
-                        return $mol_fail(new TypeError('Wrong item', { cause: { index, error, value, schema: this } }));
-                    }
+                for (const Schema of Schemas) {
+                    Schema.guard(value);
                 }
                 return value;
             }
             static cast(value) {
-                if (!Array.isArray(value))
-                    return this.default;
-                return value.map(item => Item.cast(item));
+                for (const Scheme of Schemas)
+                    value = Scheme.cast(value);
+                return value;
             }
-            static default = [];
+            static default = Schemas.find(Scheme => this.check(Scheme.default));
         };
-    }
-    $.$mol_schema_list = $mol_schema_list;
+    });
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_dict(Key, Val) {
-        return class $mol_schema_dict_ extends $mol_schema_any {
-            static Key = Key;
-            static Val = Val;
+    $.$mol_schema_range = $mol_memo_key.func(function $mol_schema_range(Range) {
+        return class $mol_schema_range_ extends $mol_schema_any {
+            static Range = Range;
             static toString() {
-                if (this !== $mol_schema_dict_)
+                if (this !== $mol_schema_range_)
                     return super.toString();
-                return '$mol_schema_dict<' + $mol_key(Key) + ',' + $mol_key(Key) + '>';
+                return '$mol_schema_range<' + $mol_key(Range) + '>';
             }
             static guard(value) {
-                if (Object.getPrototypeOf(Object.getPrototypeOf(value))) {
-                    return $mol_fail(new TypeError('Non dictionary', { cause: { value, schema: this } }));
-                }
-                for (const key in value) {
-                    try {
-                        Key.guard(key);
-                    }
-                    catch (error) {
-                        return $mol_fail(new TypeError('Wrong key', { cause: { key, error, value, schema: this } }));
-                    }
-                    try {
-                        Val.guard(value[key]);
-                    }
-                    catch (error) {
-                        return $mol_fail(new TypeError('Wrong val', { cause: { key, error, value, schema: this } }));
-                    }
-                }
+                if (typeof value !== 'number' && typeof value !== 'bigint')
+                    return $mol_fail(new TypeError('Uncomparable type', { cause: { value, schema: this } }));
+                if (!(value <= Range[1]))
+                    return $mol_fail(new TypeError('Too large', { cause: { value, schema: this } }));
+                if (!(value >= Range[0]))
+                    return $mol_fail(new TypeError('Too small', { cause: { value, schema: this } }));
                 return value;
             }
             static cast(value) {
-                if (Object.getPrototypeOf(Object.getPrototypeOf(value)))
-                    return this.default;
-                const res = {};
-                for (const key in value) {
-                    if (!Key.check(key))
-                        continue;
-                    res[key] = Val.cast(value[key]);
-                }
-                return res;
+                if (value > Range[1])
+                    return Range[1];
+                if (value >= Range[0])
+                    return value;
+                return Range[0];
             }
-            static default = {};
+            static default = Range[0];
         };
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_positive extends $mol_schema_range([0, Number.POSITIVE_INFINITY]) {
     }
-    $.$mol_schema_dict = $mol_schema_dict;
+    $.$mol_schema_positive = $mol_schema_positive;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_natural extends $mol_schema_every([
+        $mol_schema_integer,
+        $mol_schema_positive,
+    ]) {
+    }
+    $.$mol_schema_natural = $mol_schema_natural;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_schema_negative extends $mol_schema_range([Number.NEGATIVE_INFINITY, 0]) {
+    }
+    $.$mol_schema_negative = $mol_schema_negative;
 })($ || ($ = {}));
 
 ;
 "use strict";
 var $;
 (function ($) {
-    function $mol_schema_record(Fields) {
+    $.$mol_schema_maybe = $mol_memo_key.func(function $mol_schema_maybe(Some) {
+        return class $mol_schema_maybe_ extends $mol_schema_any {
+            static Some = Some;
+            static toString() {
+                if (this !== $mol_schema_maybe_)
+                    return super.toString();
+                return '$mol_schema_maybe<' + $mol_key(Some) + '>';
+            }
+            static guard(value) {
+                if (value == null)
+                    return value;
+                return Some.guard(value);
+            }
+            static default = null;
+        };
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_schema_record = $mol_memo_key.func(function $mol_schema_record(Fields) {
         return class $mol_schema_record_ extends $mol_schema_any {
             static Fields = Fields;
             static toString() {
@@ -624,8 +920,7 @@ var $;
             }
             static default = Object.fromEntries(Object.entries(Fields).map(([field, Field]) => [field, Field.default]));
         };
-    }
-    $.$mol_schema_record = $mol_schema_record;
+    });
 })($ || ($ = {}));
 
 ;
@@ -660,17 +955,7 @@ var $;
             return false;
         }
     }
-    $.$mol_promise_like = $mol_promise_like;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    function $mol_fail_hidden(error) {
-        throw error; /// Use 'Never Pause Here' breakpoint in DevTools or simply blackbox this script
-    }
-    $.$mol_fail_hidden = $mol_fail_hidden;
+    $.$mol_promise_like = $mol_promise_like;
 })($ || ($ = {}));
 
 ;
@@ -938,79 +1223,6 @@ var $;
     });
 })($ || ($ = {}));
 
-;
-"use strict";
-var $;
-(function ($) {
-    $.$mol_ambient_ref = Symbol('$mol_ambient_ref');
-    function $mol_ambient(overrides) {
-        return Object.setPrototypeOf(overrides, this || $);
-    }
-    $.$mol_ambient = $mol_ambient;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    $.$mol_owning_map = new WeakMap();
-    function $mol_owning_allow(having) {
-        try {
-            if (!having)
-                return false;
-            if (typeof having !== 'object' && typeof having !== 'function')
-                return false;
-            if (having instanceof $mol_delegate)
-                return false;
-            if (typeof having['destructor'] !== 'function')
-                return false;
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    $.$mol_owning_allow = $mol_owning_allow;
-    function $mol_owning_get(having, Owner) {
-        if (!$mol_owning_allow(having))
-            return null;
-        while (true) {
-            const owner = $.$mol_owning_map.get(having);
-            if (!owner)
-                return owner;
-            if (!Owner)
-                return owner;
-            if (owner instanceof Owner)
-                return owner;
-            having = owner;
-        }
-    }
-    $.$mol_owning_get = $mol_owning_get;
-    function $mol_owning_check(owner, having) {
-        if (!$mol_owning_allow(having))
-            return false;
-        if ($.$mol_owning_map.get(having) !== owner)
-            return false;
-        return true;
-    }
-    $.$mol_owning_check = $mol_owning_check;
-    function $mol_owning_catch(owner, having) {
-        if (!$mol_owning_allow(having))
-            return false;
-        if ($.$mol_owning_map.get(having))
-            return false;
-        $.$mol_owning_map.set(having, owner);
-        return true;
-    }
-    $.$mol_owning_catch = $mol_owning_catch;
-})($ || ($ = {}));
-
-;
-"use strict";
-
-;
-"use strict";
-
 ;
 "use strict";
 
@@ -1028,57 +1240,6 @@ var $;
 
 ;
 "use strict";
-var $;
-(function ($) {
-    if (!Symbol.dispose)
-        Symbol.dispose = Symbol('Symbol.dispose');
-    class $mol_object2 {
-        static $ = $;
-        [Symbol.toStringTag];
-        [$mol_ambient_ref] = null;
-        get $() {
-            if (this[$mol_ambient_ref])
-                return this[$mol_ambient_ref];
-            const owner = $mol_owning_get(this);
-            return this[$mol_ambient_ref] = owner?.$ || this.constructor.$ || $mol_object2.$;
-        }
-        set $(next) {
-            if (this[$mol_ambient_ref])
-                $mol_fail_hidden(new Error('Context already defined'));
-            this[$mol_ambient_ref] = next;
-        }
-        static create(init) {
-            const obj = new this;
-            if (init)
-                init(obj);
-            return obj;
-        }
-        static [Symbol.toPrimitive]() {
-            return this.toString();
-        }
-        static toString() {
-            return this[Symbol.toStringTag] || this.$.$mol_func_name(this);
-        }
-        static toJSON() {
-            return this.toString();
-        }
-        static [$mol_key_handle]() {
-            return this.toString();
-        }
-        destructor() { }
-        static destructor() { }
-        [Symbol.dispose]() {
-            this.destructor();
-        }
-        //[ Symbol.toPrimitive ]( hint: string ) {
-        //	return hint === 'number' ? this.valueOf() : this.toString()
-        //}
-        toString() {
-            return this[Symbol.toStringTag] || this.constructor.name + '<>';
-        }
-    }
-    $.$mol_object2 = $mol_object2;
-})($ || ($ = {}));
 
 ;
 "use strict";
@@ -1433,12 +1594,18 @@ var $;
         'color': 'gray',
     });
     $.$mol_dev_format_indent = $.$mol_dev_format_div.bind(null, {
-        'margin-left': '13px'
+        'margin-inline-start': '13px'
     });
     class Stack extends Array {
         // [ Symbol.toPrimitive ]() {
         // 	return this.toString()
         // }
+        match(...args) {
+            return this.toString().match(...args);
+        }
+        split(...args) {
+            return this.toString().split(...args);
+        }
         toString() {
             return this.join('\n');
         }
@@ -2276,14 +2443,14 @@ var $;
                 reuse: if (existen) {
                     if (!existen.temp)
                         break reuse;
-                    if (existen.task !== task) {
-                        cause = 'task';
-                        break reuse;
-                    }
                     if (existen.host !== host) {
                         cause = 'host';
                         break reuse;
                     }
+                    if (existen.task !== task) {
+                        cause = 'task';
+                        break reuse;
+                    }
                     if (!$mol_compare_deep(existen.args, args)) {
                         cause = 'args';
                         break reuse;
@@ -2901,7 +3068,7 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_dom_context = new $node.jsdom.JSDOM('', { url: 'https://localhost/' }).window;
+    $.$mol_dom_context = new $node.jsdom.JSDOM('', { url: `http://${process.env.DOMAIN || 'localhost'}/` }).window;
 })($ || ($ = {}));
 
 ;
@@ -3919,6 +4086,149 @@ var $;
     });
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'run callback'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            $mol_assert_equal(Plus1.run(() => 2), 3);
+        },
+        'wrap function'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            const obj = {
+                level: 2,
+                pow: Plus1.func(function (a) {
+                    return a ** this.level;
+                })
+            };
+            $mol_assert_equal(obj.pow(2), 5);
+        },
+        'decorate field getter'() {
+            class Plus1 extends $mol_wrapper {
+                static last = 0;
+                static wrap(task) {
+                    return function (...args) {
+                        return Plus1.last = (task.call(this, ...args) || 0) + 1;
+                    };
+                }
+            }
+            class Foo {
+                static get two() {
+                    return 1;
+                }
+                static set two(next) { }
+            }
+            __decorate([
+                Plus1.field
+            ], Foo, "two", null);
+            $mol_assert_equal(Foo.two, 2);
+            Foo.two = 3;
+            $mol_assert_equal(Plus1.last, 2);
+            $mol_assert_equal(Foo.two, 2);
+        },
+        'decorate instance method'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            class Foo1 {
+                level = 2;
+                pow(a) {
+                    return a ** this.level;
+                }
+            }
+            __decorate([
+                Plus1.method
+            ], Foo1.prototype, "pow", null);
+            const Foo2 = Foo1;
+            const foo = new Foo2;
+            $mol_assert_equal(foo.pow(2), 5);
+        },
+        'decorate static method'() {
+            class Plus1 extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        return task.call(this, ...args) + 1;
+                    };
+                }
+            }
+            class Foo {
+                static level = 2;
+                static pow(a) {
+                    return a ** this.level;
+                }
+            }
+            __decorate([
+                Plus1.method
+            ], Foo, "pow", null);
+            $mol_assert_equal(Foo.pow(2), 5);
+        },
+        'decorate class'() {
+            class BarInc extends $mol_wrapper {
+                static wrap(task) {
+                    return function (...args) {
+                        const foo = task.call(this, ...args);
+                        foo.bar++;
+                        return foo;
+                    };
+                }
+            }
+            let Foo = class Foo {
+                bar;
+                constructor(bar) {
+                    this.bar = bar;
+                }
+            };
+            Foo = __decorate([
+                BarInc.class
+            ], Foo);
+            $mol_assert_equal(new Foo(2).bar, 3);
+        },
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'memoize field'() {
+            class Foo {
+                static one = 1;
+                static get two() {
+                    return ++this.one;
+                }
+                static set two(next) { }
+            }
+            __decorate([
+                $mol_memo.field
+            ], Foo, "two", null);
+            $mol_assert_equal(Foo.two, 2);
+            $mol_assert_equal(Foo.two, 2);
+            Foo.two = 3;
+            $mol_assert_equal(Foo.two, 3);
+            $mol_assert_equal(Foo.two, 3);
+        },
+    });
+})($ || ($ = {}));
+
 ;
 "use strict";
 /** @jsx $mol_jsx */
@@ -3994,6 +4304,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of enum schema"($) {
+                $mol_assert_equal($mol_schema_enum(['foo']), $mol_schema_enum(['foo']));
+                $mol_assert_unique($mol_schema_enum(['foo']), $mol_schema_enum(['bar']));
+            },
             "Enum options"($) {
                 const Config = $mol_schema_enum([123, 'foo']);
                 $mol_assert_equal('$mol_schema_enum<[123,"foo"]>', Config + '', $mol_key(Config));
@@ -4006,7 +4320,7 @@ var $;
                 $mol_assert_equal(Config.cast('foo'), 'foo');
                 $mol_assert_equal(Config.cast('bar'), 123);
                 $mol_assert_equal(123, Config.guard(123));
-                $mol_assert_fail(() => Config.guard(321), 'No one option');
+                $mol_assert_fail(() => Config.guard(321), 'Wrong option');
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));
@@ -4061,6 +4375,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of some schema"($) {
+                $mol_assert_equal($mol_schema_some([$mol_schema_float]), $mol_schema_some([$mol_schema_float]));
+                $mol_assert_unique($mol_schema_some([$mol_schema_float]), $mol_schema_some([$mol_schema_string]));
+            },
             "Some variant"($) {
                 const Config = $mol_schema_some([$mol_schema_float, $mol_schema_string]);
                 $mol_assert_equal('$mol_schema_some<[$mol_schema_float,$mol_schema_string]>', Config + '');
@@ -4071,7 +4389,7 @@ var $;
                 $mol_assert_equal('foo', Config.cast('foo'));
                 $mol_assert_equal(Number.NaN, Config.cast(true));
                 $mol_assert_equal(123, Config.guard(123));
-                $mol_assert_fail(() => Config.guard(false), 'No one variant');
+                $mol_assert_fail(() => Config.guard(false), 'Wrong variant');
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));
@@ -4084,6 +4402,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of maybe schema"($) {
+                $mol_assert_equal($mol_schema_maybe($mol_schema_float), $mol_schema_maybe($mol_schema_float));
+                $mol_assert_unique($mol_schema_maybe($mol_schema_float), $mol_schema_maybe($mol_schema_string));
+            },
             "Optional value"($) {
                 const Config = $mol_schema_maybe($mol_schema_string);
                 $mol_assert_equal('$mol_schema_maybe<$mol_schema_string>', Config + '');
@@ -4094,9 +4416,9 @@ var $;
                 $mol_assert_equal('foo', Config.cast('foo'));
                 $mol_assert_equal(undefined, Config.cast(undefined));
                 $mol_assert_equal(null, Config.cast(null));
-                $mol_assert_equal(undefined, Config.cast(0));
+                $mol_assert_equal(null, Config.cast(0));
                 $mol_assert_equal('foo', Config.guard('foo'));
-                $mol_assert_fail(() => Config.guard(123), 'No one variant');
+                $mol_assert_fail(() => Config.guard(123), 'Wrong type');
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));
@@ -4139,8 +4461,12 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of range schema"($) {
+                $mol_assert_equal($mol_schema_range([0, 1]), $mol_schema_range([0, 1]));
+                $mol_assert_unique($mol_schema_range([0, 1]), $mol_schema_range([0, 2]));
+            },
             "Float range schema"($) {
-                const Range = $mol_schema_range(4, 8);
+                const Range = $mol_schema_range([4, 8]);
                 $mol_assert_equal(true, Range.check(5.5));
                 $mol_assert_equal(true, Range.check(4));
                 $mol_assert_equal(true, Range.check(8));
@@ -4165,9 +4491,13 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of every schema"($) {
+                $mol_assert_equal($mol_schema_every([$mol_schema_float]), $mol_schema_every([$mol_schema_float]));
+                $mol_assert_unique($mol_schema_every([$mol_schema_float]), $mol_schema_every([$mol_schema_string]));
+            },
             "Range intersection"($) {
-                const Narrow = $mol_schema_every([$mol_schema_integer, $mol_schema_range(1, 8), $mol_schema_range(4, 10)]);
-                $mol_assert_equal('$mol_schema_every<[$mol_schema_integer,$mol_schema_range<1,8>,$mol_schema_range<4,10>]>', Narrow + '');
+                const Narrow = $mol_schema_every([$mol_schema_integer, $mol_schema_range([1, 8]), $mol_schema_range([4, 10])]);
+                $mol_assert_equal('$mol_schema_every<[$mol_schema_integer,$mol_schema_range<[1,8]>,$mol_schema_range<[4,10]>]>', Narrow + '');
                 $mol_assert_equal(true, Narrow.check(6));
                 $mol_assert_equal(true, Narrow.check(4));
                 $mol_assert_equal(true, Narrow.check(8));
@@ -4193,6 +4523,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of list schema"($) {
+                $mol_assert_equal($mol_schema_list($mol_schema_float), $mol_schema_list($mol_schema_float));
+                $mol_assert_unique($mol_schema_list($mol_schema_float), $mol_schema_list($mol_schema_string));
+            },
             "Array schema"($) {
                 const Vector = $mol_schema_list($mol_schema_float);
                 $mol_assert_equal('$mol_schema_list<$mol_schema_float>', Vector + '');
@@ -4217,6 +4551,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of pattern schema"($) {
+                $mol_assert_equal($mol_schema_pattern(/foo/), $mol_schema_pattern(/foo/));
+                $mol_assert_unique($mol_schema_pattern(/foo/), $mol_schema_pattern(/bar/));
+            },
             "String pattern schema"($) {
                 const Email = $mol_schema_pattern(/^.*@.*$/);
                 $mol_assert_equal('$mol_schema_pattern</^.*@.*$/>', Email + '', $mol_key(Email));
@@ -4260,8 +4598,12 @@ var $;
 var $;
 (function ($_1) {
     $mol_test({
+        "Cache of dict schema"($) {
+            $mol_assert_equal($mol_schema_dict([$mol_schema_string, $mol_schema_float]), $mol_schema_dict([$mol_schema_string, $mol_schema_float]));
+            $mol_assert_unique($mol_schema_dict([$mol_schema_string, $mol_schema_float]), $mol_schema_dict([$mol_schema_string, $mol_schema_string]));
+        },
         "Dictionary schema"($) {
-            const Flags = $mol_schema_dict($mol_schema_pattern(/^[a-z]+$/), $mol_schema_boolean);
+            const Flags = $mol_schema_dict([$mol_schema_pattern(/^[a-z]+$/), $mol_schema_boolean]);
             $mol_assert_equal(true, Flags.check({}));
             $mol_assert_equal(true, Flags.check({ foo: false }));
             $mol_assert_equal(false, Flags.check({ f00: false }));
@@ -4284,6 +4626,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of record schema"($) {
+                $mol_assert_equal($mol_schema_record({ foo: $mol_schema_float }), $mol_schema_record({ foo: $mol_schema_float }));
+                $mol_assert_unique($mol_schema_record({ foo: $mol_schema_float }), $mol_schema_record({ foo: $mol_schema_string }));
+            },
             "Record schema"($) {
                 const User = $mol_schema_record({
                     name: $mol_schema_string,
@@ -4334,7 +4680,7 @@ var $;
                 });
                 $mol_assert_equal(true, User.check({ name: 'foo', age: 123 }));
                 $mol_assert_equal(true, User.check({ name: null }));
-                $mol_assert_equal({ name: 'foo', age: undefined }, User.cast({ name: 'foo', age: false }));
+                $mol_assert_equal({ name: 'foo', age: null }, User.cast({ name: 'foo', age: false }));
                 $mol_assert_equal({ name: 'foo', age: undefined }, User.guard({ name: 'foo', age: undefined }));
                 $mol_assert_fail(() => User.guard({ name: 'foo', age: 'bar' }), 'Wrong field');
             },
@@ -4369,6 +4715,10 @@ var $;
     var $$;
     (function ($$) {
         $mol_test({
+            "Cache of instance schema"($) {
+                $mol_assert_equal($mol_schema_instance(Uint8Array), $mol_schema_instance(Uint8Array));
+                $mol_assert_unique($mol_schema_instance(Uint8Array), $mol_schema_instance(Int8Array));
+            },
             "Class instance schema"($) {
                 const Blob = $mol_schema_instance(Uint8Array);
                 $mol_assert_equal('$mol_schema_instance<Uint8Array>', Blob + '', $mol_key(Blob));
@@ -4376,7 +4726,7 @@ var $;
                 $mol_assert_equal(false, Blob.check(new Int8Array));
                 $mol_assert_equal(false, Blob.check(null));
                 $mol_assert_equal(new Uint8Array([0, 1]), Blob.cast(new Uint8Array([0, 1])));
-                $mol_assert_equal(new Uint8Array, Blob.cast(new Int8Array([1, -1])));
+                $mol_assert_fail(() => Blob.cast(new Int8Array), 'Wrong class');
                 $mol_assert_equal(new Uint8Array, Blob.guard(new Uint8Array));
                 $mol_assert_fail(() => Blob.guard(new Int8Array), 'Wrong class');
             },
@@ -4401,43 +4751,50 @@ var $;
 ;
 "use strict";
 var $;
-(function ($) {
-    const instances = new WeakSet();
-    /**
-     * Proxy that delegates all to lazy returned target.
-     *
-     * 	$mol_delegate( Array.prototype , ()=> fetch_array() )
-     */
-    function $mol_delegate(proto, target) {
-        const proxy = new Proxy(proto, {
-            get: (_, field) => {
-                const obj = target();
-                let val = Reflect.get(obj, field);
-                if (typeof val === 'function') {
-                    val = val.bind(obj);
+(function ($_1) {
+    var $$;
+    (function ($$) {
+        $mol_test({
+            "Integers as recursive Sets"($) {
+                class Schema extends $mol_schema_lazy(() => $mol_schema_list(Schema)) {
                 }
-                return val;
+                $mol_assert_equal(Schema.default, []);
+                $mol_assert_equal(Schema.check([]), true);
+                $mol_assert_equal(Schema.check(''), false);
+                $mol_assert_equal(Schema.guard([]), []);
+                $mol_assert_fail(() => Schema.guard(''), 'Non array');
+                $mol_assert_equal(Schema.cast([]), []);
+                $mol_assert_equal(Schema.cast(''), []);
             },
-            has: (_, field) => Reflect.has(target(), field),
-            set: (_, field, value) => Reflect.set(target(), field, value),
-            getOwnPropertyDescriptor: (_, field) => Reflect.getOwnPropertyDescriptor(target(), field),
-            ownKeys: () => Reflect.ownKeys(target()),
-            getPrototypeOf: () => Reflect.getPrototypeOf(target()),
-            setPrototypeOf: (_, donor) => Reflect.setPrototypeOf(target(), donor),
-            isExtensible: () => Reflect.isExtensible(target()),
-            preventExtensions: () => Reflect.preventExtensions(target()),
-            apply: (_, self, args) => Reflect.apply(target(), self, args),
-            construct: (_, args, retarget) => Reflect.construct(target(), args, retarget),
-            defineProperty: (_, field, descr) => Reflect.defineProperty(target(), field, descr),
-            deleteProperty: (_, field) => Reflect.deleteProperty(target(), field),
         });
-        instances.add(proxy);
-        return proxy;
-    }
-    $.$mol_delegate = $mol_delegate;
-    Reflect.defineProperty($mol_delegate, Symbol.hasInstance, {
-        value: (obj) => instances.has(obj),
-    });
+    })($$ = $_1.$$ || ($_1.$$ = {}));
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($_1) {
+    var $$;
+    (function ($$) {
+        $mol_test({
+            "JSON schema"($) {
+                $mol_assert_equal('$mol_schema_json', $mol_schema_json + '', $mol_key($mol_schema_json));
+                $mol_assert_equal(true, $mol_schema_json.check(null));
+                $mol_assert_equal(true, $mol_schema_json.check(0));
+                $mol_assert_equal(true, $mol_schema_json.check(false));
+                $mol_assert_equal(true, $mol_schema_json.check(''));
+                $mol_assert_equal(true, $mol_schema_json.check([]));
+                $mol_assert_equal(true, $mol_schema_json.check({}));
+                $mol_assert_equal(false, $mol_schema_json.check(undefined));
+                $mol_assert_equal(false, $mol_schema_json.check(new Date));
+                $mol_assert_equal(false, $mol_schema_json.check({ __proto__: {} }));
+                $mol_assert_equal({}, $mol_schema_json.cast(new Date));
+                $mol_assert_equal({ foo: 777, bar: {} }, $mol_schema_json.cast({ foo: 777, bar: new Date }));
+                $mol_assert_equal({ foo: [null, 0, false, ''] }, $mol_schema_json.guard({ foo: [null, 0, false, ''] }));
+                $mol_assert_fail(() => $mol_schema_json.guard({ foo: [new Date] }), 'Wrong variant');
+            },
+        });
+    })($$ = $_1.$$ || ($_1.$$ = {}));
 })($ || ($ = {}));
 
 ;
@@ -5371,7 +5728,7 @@ var $;
                 } + '', class Some extends $mol_schema_maybe($mol_schema_float) {
                 } + '', class Some extends $mol_schema_every([$mol_schema_float]) {
                 } + '', class Some extends $mol_schema_list($mol_schema_float) {
-                } + '', class Some extends $mol_schema_dict($mol_schema_string, $mol_schema_string) {
+                } + '', class Some extends $mol_schema_dict([$mol_schema_string, $mol_schema_string]) {
                 } + '', class Some extends $mol_schema_record({ name: $mol_schema_string }) {
                 } + '', class Some extends $mol_schema_partial({ name: $mol_schema_string }) {
                 } + '');