mol_data_all 1.1.209 → 1.1.213

package/node.test.js

@@ -19,10 +19,10 @@ var $;
 (function ($) {
 })($ || ($ = {}));
 module.exports = $;
-//mam.js.map
+//mam.ts
 ;
 "use strict";
-//value.js.map
+//mol/data/value/value.ts
 ;
 "use strict";
 var $;
@@ -35,7 +35,7 @@ var $;
     }
     $.$mol_data_setup = $mol_data_setup;
 })($ || ($ = {}));
-//setup.js.map
+//mol/data/setup/setup.ts
 ;
 "use strict";
 var $;
@@ -45,7 +45,7 @@ var $;
     }
     $.$mol_fail = $mol_fail;
 })($ || ($ = {}));
-//fail.js.map
+//mol/fail/fail.ts
 ;
 "use strict";
 var $;
@@ -66,7 +66,7 @@ var $;
     }
     $.$mol_diff_path = $mol_diff_path;
 })($ || ($ = {}));
-//path.js.map
+//mol/diff/path/path.ts
 ;
 "use strict";
 var $;
@@ -78,7 +78,7 @@ var $;
             this.errors = errors;
             if (errors.length) {
                 const stacks = [...errors.map(error => error.stack), this.stack];
-                const diff = $.$mol_diff_path(...stacks.map(stack => {
+                const diff = $mol_diff_path(...stacks.map(stack => {
                     if (!stack)
                         return [];
                     return stack.split('\n').reverse();
@@ -95,16 +95,16 @@ var $;
     }
     $.$mol_error_mix = $mol_error_mix;
 })($ || ($ = {}));
-//mix.js.map
+//mol/error/mix/mix.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    class $mol_data_error extends $.$mol_error_mix {
+    class $mol_data_error extends $mol_error_mix {
     }
     $.$mol_data_error = $mol_data_error;
 })($ || ($ = {}));
-//error.js.map
+//mol/data/error/error.ts
 ;
 "use strict";
 var $;
@@ -114,31 +114,31 @@ var $;
     }
     $.$mol_fail_hidden = $mol_fail_hidden;
 })($ || ($ = {}));
-//hidden.js.map
+//mol/fail/hidden/hidden.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_array(sub) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             if (!Array.isArray(val))
-                return $.$mol_fail(new $.$mol_data_error(`${val} is not an array`));
+                return $mol_fail(new $mol_data_error(`${val} is not an array`));
             return val.map((item, index) => {
                 try {
                     return sub(item);
                 }
                 catch (error) {
-                    if ('then' in error)
-                        return $.$mol_fail_hidden(error);
+                    if (error instanceof Promise)
+                        return $mol_fail_hidden(error);
                     error.message = `[${index}] ${error.message}`;
-                    return $.$mol_fail(error);
+                    return $mol_fail(error);
                 }
             });
         }, sub);
     }
     $.$mol_data_array = $mol_data_array;
 })($ || ($ = {}));
-//array.js.map
+//mol/data/array/array.ts
 ;
 "use strict";
 var $;
@@ -146,24 +146,24 @@ var $;
     $.$mol_data_boolean = (val) => {
         if (typeof val === 'boolean')
             return val;
-        return $.$mol_fail(new $.$mol_data_error(`${val} is not a boolean`));
+        return $mol_fail(new $mol_data_error(`${val} is not a boolean`));
     };
 })($ || ($ = {}));
-//boolean.js.map
+//mol/data/boolean/boolean.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_const(ref) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             if (Object.is(val, ref))
                 return ref;
-            return $.$mol_fail(new $.$mol_data_error(`${val} is not ${ref}`));
+            return $mol_fail(new $mol_data_error(`${val} is not ${ref}`));
         }, ref);
     }
     $.$mol_data_const = $mol_data_const;
 })($ || ($ = {}));
-//const.js.map
+//mol/data/const/const.ts
 ;
 "use strict";
 var $;
@@ -171,32 +171,32 @@ var $;
     $.$mol_data_string = (val) => {
         if (typeof val === 'string')
             return val;
-        return $.$mol_fail(new $.$mol_data_error(`${val} is not a string`));
+        return $mol_fail(new $mol_data_error(`${val} is not a string`));
     };
 })($ || ($ = {}));
-//string.js.map
+//mol/data/string/string.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_pattern(pattern) {
-        return $.$mol_data_setup((val) => {
-            const val2 = $.$mol_data_string(val);
+        return $mol_data_setup((val) => {
+            const val2 = $mol_data_string(val);
             if (pattern.test(val2))
                 return val2;
-            return $.$mol_fail(new $.$mol_data_error(`${val} is not a ${pattern}`));
+            return $mol_fail(new $mol_data_error(`${val} is not a ${pattern}`));
         }, pattern);
     }
     $.$mol_data_pattern = $mol_data_pattern;
 })($ || ($ = {}));
-//pattern.js.map
+//mol/data/pattern/pattern.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_data_email = $.$mol_data_pattern(/.+@.+/);
+    $.$mol_data_email = $mol_data_pattern(/.+@.+/);
 })($ || ($ = {}));
-//email.js.map
+//mol/data/email/email.ts
 ;
 "use strict";
 var $;
@@ -208,30 +208,30 @@ var $;
                 index[dict[key]] = key;
             }
         }
-        return $.$mol_data_setup((value) => {
+        return $mol_data_setup((value) => {
             if (typeof index[value] !== 'string') {
-                return $.$mol_fail(new $.$mol_data_error(`${value} is not value of ${name} enum`));
+                return $mol_fail(new $mol_data_error(`${value} is not value of ${name} enum`));
             }
             return value;
         }, { name, dict });
     }
     $.$mol_data_enum = $mol_data_enum;
 })($ || ($ = {}));
-//enum.js.map
+//mol/data/enum/enum.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_instance(Instance) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             if (val instanceof Instance)
                 return val;
-            return $.$mol_fail(new $.$mol_data_error(`${val} is not a ${Instance.name}`));
+            return $mol_fail(new $mol_data_error(`${val} is not a ${Instance.name}`));
         }, Instance);
     }
     $.$mol_data_instance = $mol_data_instance;
 })($ || ($ = {}));
-//instance.js.map
+//mol/data/instance/instance.ts
 ;
 "use strict";
 var $;
@@ -239,23 +239,23 @@ var $;
     $.$mol_data_number = (val) => {
         if (typeof val === 'number')
             return val;
-        return $.$mol_fail(new $.$mol_data_error(`${val} is not a number`));
+        return $mol_fail(new $mol_data_error(`${val} is not a number`));
     };
 })($ || ($ = {}));
-//number.js.map
+//mol/data/number/number.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_integer(val) {
-        const val2 = $.$mol_data_number(val);
+        const val2 = $mol_data_number(val);
         if (Math.floor(val2) === val2)
             return val2;
-        return $.$mol_fail(new $.$mol_data_error(`${val} is not an integer`));
+        return $mol_fail(new $mol_data_error(`${val} is not an integer`));
     }
     $.$mol_data_integer = $mol_data_integer;
 })($ || ($ = {}));
-//integer.js.map
+//mol/data/integer/integer.ts
 ;
 "use strict";
 var $;
@@ -266,13 +266,13 @@ var $;
     }
     $.$mol_data_nominal = $mol_data_nominal;
 })($ || ($ = {}));
-//nominal.js.map
+//mol/data/nominal/nominal.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_nullable(sub) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             if (val === null)
                 return null;
             return sub(val);
@@ -280,13 +280,13 @@ var $;
     }
     $.$mol_data_nullable = $mol_data_nullable;
 })($ || ($ = {}));
-//nullable.js.map
+//mol/data/nullable/nullable.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_optional(sub, fallback) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             if (val === undefined) {
                 return fallback?.();
             }
@@ -295,32 +295,32 @@ var $;
     }
     $.$mol_data_optional = $mol_data_optional;
 })($ || ($ = {}));
-//optional.js.map
+//mol/data/optional/optional.ts
 ;
 "use strict";
-//equals.js.map
+//mol/type/equals/equals.ts
 ;
 "use strict";
-//merge.js.map
+//mol/type/merge/merge.ts
 ;
 "use strict";
-//undefined.js.map
+//mol/type/partial/undefined/undefined.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_record(sub) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             let res = {};
             for (const field in sub) {
                 try {
                     res[field] = sub[field](val[field]);
                 }
                 catch (error) {
-                    if ('then' in error)
-                        return $.$mol_fail_hidden(error);
+                    if (error instanceof Promise)
+                        return $mol_fail_hidden(error);
                     error.message = `[${JSON.stringify(field)}] ${error.message}`;
-                    return $.$mol_fail(error);
+                    return $mol_fail(error);
                 }
             }
             return res;
@@ -328,13 +328,13 @@ var $;
     }
     $.$mol_data_record = $mol_data_record;
 })($ || ($ = {}));
-//record.js.map
+//mol/data/record/record.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_variant(...sub) {
-        return $.$mol_data_setup((val) => {
+        return $mol_data_setup((val) => {
             const errors = [];
             for (const type of sub) {
                 let hidden = $.$mol_fail_hidden;
@@ -344,29 +344,29 @@ var $;
                 }
                 catch (error) {
                     $.$mol_fail = hidden;
-                    if (error instanceof $.$mol_data_error) {
+                    if (error instanceof $mol_data_error) {
                         errors.push(error);
                     }
                     else {
-                        return $.$mol_fail_hidden(error);
+                        return $mol_fail_hidden(error);
                     }
                 }
             }
-            return $.$mol_fail(new $.$mol_data_error(`${val} is not any of variants`, ...errors));
+            return $mol_fail(new $mol_data_error(`${val} is not any of variants`, ...errors));
         }, sub);
     }
     $.$mol_data_variant = $mol_data_variant;
 })($ || ($ = {}));
-//variant.js.map
+//mol/data/variant/variant.ts
 ;
 "use strict";
-//unary.js.map
+//mol/type/unary/unary.ts
 ;
 "use strict";
-//param.js.map
+//mol/type/param/param.ts
 ;
 "use strict";
-//tail.js.map
+//mol/type/tail/tail.ts
 ;
 "use strict";
 var $;
@@ -376,39 +376,39 @@ var $;
     }
     $.$mol_func_is_class = $mol_func_is_class;
 })($ || ($ = {}));
-//class.js.map
+//mol/func/is/class/class.ts
 ;
 "use strict";
-//result.js.map
+//mol/type/result/result.ts
 ;
 "use strict";
-//foot.js.map
+//mol/type/foot/foot.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_pipe(...funcs) {
-        return $.$mol_data_setup(function (input) {
+        return $mol_data_setup(function (input) {
             let value = input;
             for (const func of funcs)
-                value = $.$mol_func_is_class(func) ? new func(value) : func.call(this, value);
+                value = $mol_func_is_class(func) ? new func(value) : func.call(this, value);
             return value;
         }, { funcs });
     }
     $.$mol_data_pipe = $mol_data_pipe;
 })($ || ($ = {}));
-//pipe.js.map
+//mol/data/pipe/pipe.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_data_wrapper(pre, Obj) {
         console.warn('$mol_data_wrapper is deparecated. Use $mol_data_pipe instead.');
-        return $.$mol_data_setup((val) => new Obj(pre(val)), { pre, Obj });
+        return $mol_data_setup((val) => new Obj(pre(val)), { pre, Obj });
     }
     $.$mol_data_wrapper = $mol_data_wrapper;
 })($ || ($ = {}));
-//wrapper.js.map
+//mol/data/wrapper/wrapper.ts
 ;
 "use strict";
 var $;
@@ -418,7 +418,7 @@ var $;
     }
     $.$mol_test_complete = $mol_test_complete;
 })($ || ($ = {}));
-//test.node.test.js.map
+//mol/test/test.node.test.ts
 ;
 "use strict";
 var $;
@@ -436,12 +436,18 @@ var $;
     $_1.$mol_test_all = [];
     async function $mol_test_run() {
         for (var test of $_1.$mol_test_all) {
-            let context = Object.create($_1.$$);
+            let context = Object.create($$);
             for (let mock of $_1.$mol_test_mocks)
                 await mock(context);
-            await test(context);
+            const res = test(context);
+            if (res instanceof Promise) {
+                await new Promise((done, fail) => {
+                    res.then(done, fail);
+                    setTimeout(() => fail(new Error('Test timeout: ' + test.name)), 1000);
+                });
+            }
         }
-        $_1.$$.$mol_log3_done({
+        $$.$mol_log3_done({
             place: '$mol_test',
             message: 'All tests passed',
             count: $_1.$mol_test_all.length,
@@ -459,7 +465,7 @@ var $;
                 await $mol_test_run();
             }
             finally {
-                $_1.$$.$mol_test_complete();
+                $$.$mol_test_complete();
             }
         }, 0);
     }
@@ -472,10 +478,10 @@ var $;
         for (let api of forbidden) {
             context[api] = new Proxy(function () { }, {
                 get() {
-                    $_1.$mol_fail_hidden(new Error(`${api} is forbidden in tests`));
+                    $mol_fail_hidden(new Error(`${api} is forbidden in tests`));
                 },
                 apply() {
-                    $_1.$mol_fail_hidden(new Error(`${api} is forbidden in tests`));
+                    $mol_fail_hidden(new Error(`${api} is forbidden in tests`));
                 },
             });
         }
@@ -503,16 +509,16 @@ var $;
         },
     });
 })($ || ($ = {}));
-//test.test.js.map
+//mol/test/test.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
 })($ || ($ = {}));
-//context.js.map
+//mol/dom/context/context.ts
 ;
 "use strict";
-//node.js.map
+//node/node.ts
 ;
 "use strict";
 var $node = new Proxy({ require }, {
@@ -551,14 +557,14 @@ var $node = new Proxy({ require }, {
 require = (req => Object.assign(function require(name) {
     return $node[name];
 }, req))(require);
-//node.node.js.map
+//node/node.node.ts
 ;
 "use strict";
 var $;
 (function ($) {
     $.$mol_dom_context = new $node.jsdom.JSDOM('', { url: 'https://localhost/' }).window;
 })($ || ($ = {}));
-//context.node.js.map
+//mol/dom/context/context.node.ts
 ;
 "use strict";
 var $;
@@ -569,7 +575,7 @@ var $;
         for (let view of childNodes) {
             if (view == null)
                 continue;
-            if (view instanceof $.$mol_dom_context.Node) {
+            if (view instanceof $mol_dom_context.Node) {
                 while (true) {
                     if (!nextNode) {
                         el.appendChild(view);
@@ -600,7 +606,7 @@ var $;
                     nextNode = nextNode.nextSibling;
                 }
                 else {
-                    const textNode = $.$mol_dom_context.document.createTextNode(String(view));
+                    const textNode = $mol_dom_context.document.createTextNode(String(view));
                     el.insertBefore(textNode, nextNode);
                 }
             }
@@ -613,88 +619,88 @@ var $;
     }
     $.$mol_dom_render_children = $mol_dom_render_children;
 })($ || ($ = {}));
-//children.js.map
+//mol/dom/render/children/children.ts
 ;
 "use strict";
-//error.js.map
+//mol/type/error/error.ts
 ;
 "use strict";
-//assert.test.js.map
+//mol/type/assert/assert.test.ts
 ;
 "use strict";
-//assert.js.map
+//mol/type/assert/assert.ts
 ;
 "use strict";
-//deep.test.js.map
+//mol/type/partial/deep/deep.test.ts
 ;
 "use strict";
-//deep.js.map
+//mol/type/partial/deep/deep.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Make empty div'() {
-            $.$mol_assert_equal(($.$mol_jsx("div", null)).outerHTML, '<div></div>');
+            $mol_assert_equal(($mol_jsx("div", null)).outerHTML, '<div></div>');
         },
         'Define native field'() {
-            const dom = $.$mol_jsx("input", { value: '123' });
-            $.$mol_assert_equal(dom.outerHTML, '<input value="123">');
-            $.$mol_assert_equal(dom.value, '123');
+            const dom = $mol_jsx("input", { value: '123' });
+            $mol_assert_equal(dom.outerHTML, '<input value="123">');
+            $mol_assert_equal(dom.value, '123');
         },
         'Define classes'() {
-            const dom = $.$mol_jsx("div", { class: 'foo bar' });
-            $.$mol_assert_equal(dom.outerHTML, '<div class="foo bar"></div>');
+            const dom = $mol_jsx("div", { class: 'foo bar' });
+            $mol_assert_equal(dom.outerHTML, '<div class="foo bar"></div>');
         },
         'Define styles'() {
-            const dom = $.$mol_jsx("div", { style: { color: 'red' } });
-            $.$mol_assert_equal(dom.outerHTML, '<div style="color: red;"></div>');
+            const dom = $mol_jsx("div", { style: { color: 'red' } });
+            $mol_assert_equal(dom.outerHTML, '<div style="color: red;"></div>');
         },
         'Define dataset'() {
-            const dom = $.$mol_jsx("div", { dataset: { foo: 'bar' } });
-            $.$mol_assert_equal(dom.outerHTML, '<div data-foo="bar"></div>');
+            const dom = $mol_jsx("div", { dataset: { foo: 'bar' } });
+            $mol_assert_equal(dom.outerHTML, '<div data-foo="bar"></div>');
         },
         'Define attributes'() {
-            const dom = $.$mol_jsx("div", { lang: "ru", hidden: true });
-            $.$mol_assert_equal(dom.outerHTML, '<div lang="ru" hidden=""></div>');
+            const dom = $mol_jsx("div", { lang: "ru", hidden: true });
+            $mol_assert_equal(dom.outerHTML, '<div lang="ru" hidden=""></div>');
         },
         'Define child nodes'() {
-            const dom = $.$mol_jsx("div", null,
+            const dom = $mol_jsx("div", null,
                 "hello",
-                $.$mol_jsx("strong", null, "world"),
+                $mol_jsx("strong", null, "world"),
                 "!");
-            $.$mol_assert_equal(dom.outerHTML, '<div>hello<strong>world</strong>!</div>');
+            $mol_assert_equal(dom.outerHTML, '<div>hello<strong>world</strong>!</div>');
         },
         'Function as component'() {
             const Button = ({ hint }, target) => {
-                return $.$mol_jsx("button", { title: hint }, target());
+                return $mol_jsx("button", { title: hint }, target());
             };
-            const dom = $.$mol_jsx(Button, { id: "/foo", hint: "click me" }, () => 'hey!');
-            $.$mol_assert_equal(dom.outerHTML, '<button title="click me" id="/foo">hey!</button>');
+            const dom = $mol_jsx(Button, { id: "/foo", hint: "click me" }, () => 'hey!');
+            $mol_assert_equal(dom.outerHTML, '<button title="click me" id="/foo">hey!</button>');
         },
         'Nested guid generation'() {
             const Foo = () => {
-                return $.$mol_jsx("div", null,
-                    $.$mol_jsx(Bar, { id: "/bar" },
-                        $.$mol_jsx("img", { id: "/icon" })));
+                return $mol_jsx("div", null,
+                    $mol_jsx(Bar, { id: "/bar" },
+                        $mol_jsx("img", { id: "/icon" })));
             };
             const Bar = (props, icon) => {
-                return $.$mol_jsx("span", null, icon);
+                return $mol_jsx("span", null, icon);
             };
-            const dom = $.$mol_jsx(Foo, { id: "/foo" });
-            $.$mol_assert_equal(dom.outerHTML, '<div id="/foo"><span id="/foo/bar"><img id="/foo/icon"></span></div>');
+            const dom = $mol_jsx(Foo, { id: "/foo" });
+            $mol_assert_equal(dom.outerHTML, '<div id="/foo"><span id="/foo/bar"><img id="/foo/icon"></span></div>');
         },
         'Fail on non unique ids'() {
             const App = () => {
-                return $.$mol_jsx("div", null,
-                    $.$mol_jsx("span", { id: "/bar" }),
-                    $.$mol_jsx("span", { id: "/bar" }));
+                return $mol_jsx("div", null,
+                    $mol_jsx("span", { id: "/bar" }),
+                    $mol_jsx("span", { id: "/bar" }));
             };
-            $.$mol_assert_fail(() => $.$mol_jsx(App, { id: "/foo" }), 'JSX already has tag with id "/bar"');
+            $mol_assert_fail(() => $mol_jsx(App, { id: "/foo" }), 'JSX already has tag with id "/bar"');
         },
     });
 })($ || ($ = {}));
-//jsx.test.js.map
+//mol/jsx/jsx.test.tsx
 ;
 "use strict";
 var $;
@@ -703,15 +709,15 @@ var $;
     $.$mol_jsx_booked = null;
     $.$mol_jsx_document = {
         getElementById: () => null,
-        createElementNS: (space, name) => $.$mol_dom_context.document.createElementNS(space, name),
-        createDocumentFragment: () => $.$mol_dom_context.document.createDocumentFragment(),
+        createElementNS: (space, name) => $mol_dom_context.document.createElementNS(space, name),
+        createDocumentFragment: () => $mol_dom_context.document.createDocumentFragment(),
     };
     $.$mol_jsx_frag = '';
     function $mol_jsx(Elem, props, ...childNodes) {
         const id = props && props.id || '';
         if (Elem && $.$mol_jsx_booked) {
             if ($.$mol_jsx_booked.has(id)) {
-                $.$mol_fail(new Error(`JSX already has tag with id ${JSON.stringify(id)}`));
+                $mol_fail(new Error(`JSX already has tag with id ${JSON.stringify(id)}`));
             }
             else {
                 $.$mol_jsx_booked.add(id);
@@ -750,7 +756,7 @@ var $;
                 ? $.$mol_jsx_document.createElementNS(props?.xmlns ?? 'http://www.w3.org/1999/xhtml', Elem)
                 : $.$mol_jsx_document.createDocumentFragment();
         }
-        $.$mol_dom_render_children(node, [].concat(...childNodes));
+        $mol_dom_render_children(node, [].concat(...childNodes));
         if (!Elem)
             return node;
         for (const key in props) {
@@ -776,77 +782,77 @@ var $;
     }
     $.$mol_jsx = $mol_jsx;
 })($ || ($ = {}));
-//jsx.js.map
+//mol/jsx/jsx.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'nulls & undefineds'() {
-            $.$mol_assert_ok($.$mol_compare_deep(null, null));
-            $.$mol_assert_ok($.$mol_compare_deep(undefined, undefined));
-            $.$mol_assert_not($.$mol_compare_deep(undefined, null));
-            $.$mol_assert_not($.$mol_compare_deep({}, null));
+            $mol_assert_ok($mol_compare_deep(null, null));
+            $mol_assert_ok($mol_compare_deep(undefined, undefined));
+            $mol_assert_not($mol_compare_deep(undefined, null));
+            $mol_assert_not($mol_compare_deep({}, null));
         },
         'number'() {
-            $.$mol_assert_ok($.$mol_compare_deep(1, 1));
-            $.$mol_assert_ok($.$mol_compare_deep(Number.NaN, Number.NaN));
-            $.$mol_assert_not($.$mol_compare_deep(1, 2));
-            $.$mol_assert_ok($.$mol_compare_deep(Object(1), Object(1)));
-            $.$mol_assert_not($.$mol_compare_deep(Object(1), Object(2)));
+            $mol_assert_ok($mol_compare_deep(1, 1));
+            $mol_assert_ok($mol_compare_deep(Number.NaN, Number.NaN));
+            $mol_assert_not($mol_compare_deep(1, 2));
+            $mol_assert_ok($mol_compare_deep(Object(1), Object(1)));
+            $mol_assert_not($mol_compare_deep(Object(1), Object(2)));
         },
         'POJO'() {
-            $.$mol_assert_ok($.$mol_compare_deep({}, {}));
-            $.$mol_assert_not($.$mol_compare_deep({ a: 1 }, { b: 2 }));
-            $.$mol_assert_not($.$mol_compare_deep({ a: 1 }, { a: 2 }));
-            $.$mol_assert_not($.$mol_compare_deep({}, { a: undefined }));
-            $.$mol_assert_ok($.$mol_compare_deep({ a: 1, b: 2 }, { b: 2, a: 1 }));
-            $.$mol_assert_ok($.$mol_compare_deep({ a: { b: 1 } }, { a: { b: 1 } }));
+            $mol_assert_ok($mol_compare_deep({}, {}));
+            $mol_assert_not($mol_compare_deep({ a: 1 }, { b: 2 }));
+            $mol_assert_not($mol_compare_deep({ a: 1 }, { a: 2 }));
+            $mol_assert_not($mol_compare_deep({}, { a: undefined }));
+            $mol_assert_ok($mol_compare_deep({ a: 1, b: 2 }, { b: 2, a: 1 }));
+            $mol_assert_ok($mol_compare_deep({ a: { b: 1 } }, { a: { b: 1 } }));
         },
         'Array'() {
-            $.$mol_assert_ok($.$mol_compare_deep([], []));
-            $.$mol_assert_ok($.$mol_compare_deep([1, [2]], [1, [2]]));
-            $.$mol_assert_not($.$mol_compare_deep([1, 2], [1, 3]));
-            $.$mol_assert_not($.$mol_compare_deep([1, 2,], [1, 3, undefined]));
+            $mol_assert_ok($mol_compare_deep([], []));
+            $mol_assert_ok($mol_compare_deep([1, [2]], [1, [2]]));
+            $mol_assert_not($mol_compare_deep([1, 2], [1, 3]));
+            $mol_assert_not($mol_compare_deep([1, 2,], [1, 3, undefined]));
         },
         'Non POJO are different'() {
             class Thing extends Object {
             }
-            $.$mol_assert_not($.$mol_compare_deep(new Thing, new Thing));
-            $.$mol_assert_not($.$mol_compare_deep(() => 1, () => 1));
-            $.$mol_assert_not($.$mol_compare_deep(new RangeError('Test error'), new RangeError('Test error')));
+            $mol_assert_not($mol_compare_deep(new Thing, new Thing));
+            $mol_assert_not($mol_compare_deep(() => 1, () => 1));
+            $mol_assert_not($mol_compare_deep(new RangeError('Test error'), new RangeError('Test error')));
         },
         'same POJOs with cyclic reference'() {
             const a = { foo: {} };
             a['self'] = a;
             const b = { foo: {} };
             b['self'] = b;
-            $.$mol_assert_ok($.$mol_compare_deep(a, b));
+            $mol_assert_ok($mol_compare_deep(a, b));
         },
         'Date'() {
-            $.$mol_assert_ok($.$mol_compare_deep(new Date(12345), new Date(12345)));
-            $.$mol_assert_not($.$mol_compare_deep(new Date(12345), new Date(12346)));
+            $mol_assert_ok($mol_compare_deep(new Date(12345), new Date(12345)));
+            $mol_assert_not($mol_compare_deep(new Date(12345), new Date(12346)));
         },
         'RegExp'() {
-            $.$mol_assert_ok($.$mol_compare_deep(/\x22/mig, /\x22/mig));
-            $.$mol_assert_not($.$mol_compare_deep(/\x22/mig, /\x21/mig));
-            $.$mol_assert_not($.$mol_compare_deep(/\x22/mig, /\x22/mg));
+            $mol_assert_ok($mol_compare_deep(/\x22/mig, /\x22/mig));
+            $mol_assert_not($mol_compare_deep(/\x22/mig, /\x21/mig));
+            $mol_assert_not($mol_compare_deep(/\x22/mig, /\x22/mg));
         },
         'Map'() {
-            $.$mol_assert_ok($.$mol_compare_deep(new Map, new Map));
-            $.$mol_assert_ok($.$mol_compare_deep(new Map([[1, [2]]]), new Map([[1, [2]]])));
-            $.$mol_assert_not($.$mol_compare_deep(new Map([[1, 2]]), new Map([[1, 3]])));
-            $.$mol_assert_not($.$mol_compare_deep(new Map([[[1], 2]]), new Map([[[1], 2]])));
+            $mol_assert_ok($mol_compare_deep(new Map, new Map));
+            $mol_assert_ok($mol_compare_deep(new Map([[1, [2]]]), new Map([[1, [2]]])));
+            $mol_assert_not($mol_compare_deep(new Map([[1, 2]]), new Map([[1, 3]])));
+            $mol_assert_not($mol_compare_deep(new Map([[[1], 2]]), new Map([[[1], 2]])));
         },
         'Set'() {
-            $.$mol_assert_ok($.$mol_compare_deep(new Set, new Set));
-            $.$mol_assert_ok($.$mol_compare_deep(new Set([1, [2]]), new Set([1, [2]])));
-            $.$mol_assert_not($.$mol_compare_deep(new Set([1]), new Set([2])));
+            $mol_assert_ok($mol_compare_deep(new Set, new Set));
+            $mol_assert_ok($mol_compare_deep(new Set([1, [2]]), new Set([1, [2]])));
+            $mol_assert_not($mol_compare_deep(new Set([1]), new Set([2])));
         },
         'Uint8Array'() {
-            $.$mol_assert_ok($.$mol_compare_deep(new Uint8Array, new Uint8Array));
-            $.$mol_assert_ok($.$mol_compare_deep(new Uint8Array([0]), new Uint8Array([0])));
-            $.$mol_assert_not($.$mol_compare_deep(new Uint8Array([0]), new Uint8Array([1])));
+            $mol_assert_ok($mol_compare_deep(new Uint8Array, new Uint8Array));
+            $mol_assert_ok($mol_compare_deep(new Uint8Array([0]), new Uint8Array([0])));
+            $mol_assert_not($mol_compare_deep(new Uint8Array([0]), new Uint8Array([1])));
         },
         'Custom comparator'() {
             class User {
@@ -860,17 +866,17 @@ var $;
                     return this.name;
                 }
             }
-            $.$mol_assert_ok($.$mol_compare_deep(new User('Jin'), new User('Jin')));
-            $.$mol_assert_not($.$mol_compare_deep(new User('Jin'), new User('John')));
+            $mol_assert_ok($mol_compare_deep(new User('Jin'), new User('Jin')));
+            $mol_assert_not($mol_compare_deep(new User('Jin'), new User('John')));
         },
     });
 })($ || ($ = {}));
-//deep.test.js.map
+//mol/compare/deep/deep.test.tsx
 ;
 "use strict";
 var $;
 (function ($) {
-    let cache = new WeakMap();
+    $.$mol_compare_deep_cache = new WeakMap();
     function $mol_compare_deep(left, right) {
         if (Object.is(left, right))
             return true;
@@ -896,7 +902,7 @@ var $;
             return Object.is(left.valueOf(), right['valueOf']());
         if (left instanceof RegExp)
             return left.source === right['source'] && left.flags === right['flags'];
-        let left_cache = cache.get(left);
+        let left_cache = $.$mol_compare_deep_cache.get(left);
         if (left_cache) {
             const right_cache = left_cache.get(right);
             if (typeof right_cache === 'boolean')
@@ -904,7 +910,7 @@ var $;
         }
         else {
             left_cache = new WeakMap([[right, true]]);
-            cache.set(left, left_cache);
+            $.$mol_compare_deep_cache.set(left, left_cache);
         }
         let result;
         try {
@@ -988,50 +994,50 @@ var $;
         return Object.is(left[Symbol.toPrimitive]('default'), right[Symbol.toPrimitive]('default'));
     }
 })($ || ($ = {}));
-//deep.js.map
+//mol/compare/deep/deep.ts
 ;
 "use strict";
 var $;
 (function ($) {
     function $mol_dom_serialize(node) {
-        const serializer = new $.$mol_dom_context.XMLSerializer;
+        const serializer = new $mol_dom_context.XMLSerializer;
         return serializer.serializeToString(node);
     }
     $.$mol_dom_serialize = $mol_dom_serialize;
 })($ || ($ = {}));
-//serialize.js.map
+//mol/dom/serialize/serialize.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'must be false'() {
-            $.$mol_assert_not(0);
+            $mol_assert_not(0);
         },
         'must be true'() {
-            $.$mol_assert_ok(1);
+            $mol_assert_ok(1);
         },
         'two must be equal'() {
-            $.$mol_assert_equal(2, 2);
+            $mol_assert_equal(2, 2);
         },
         'three must be equal'() {
-            $.$mol_assert_equal(2, 2, 2);
+            $mol_assert_equal(2, 2, 2);
         },
         'two must be unique'() {
-            $.$mol_assert_unique([3], [3]);
+            $mol_assert_unique([3], [3]);
         },
         'three must be unique'() {
-            $.$mol_assert_unique([3], [3], [3]);
+            $mol_assert_unique([3], [3], [3]);
         },
         'two must be alike'() {
-            $.$mol_assert_like([3], [3]);
+            $mol_assert_like([3], [3]);
         },
         'three must be alike'() {
-            $.$mol_assert_like([3], [3], [3]);
+            $mol_assert_like([3], [3], [3]);
         },
     });
 })($ || ($ = {}));
-//assert.test.js.map
+//mol/assert/assert.test.ts
 ;
 "use strict";
 var $;
@@ -1039,13 +1045,13 @@ var $;
     function $mol_assert_ok(value) {
         if (value)
             return;
-        $.$mol_fail(new Error(`${value} ≠ true`));
+        $mol_fail(new Error(`${value} ≠ true`));
     }
     $.$mol_assert_ok = $mol_assert_ok;
     function $mol_assert_not(value) {
         if (!value)
             return;
-        $.$mol_fail(new Error(`${value} ≠ false`));
+        $mol_fail(new Error(`${value} ≠ false`));
     }
     $.$mol_assert_not = $mol_assert_not;
     function $mol_assert_fail(handler, ErrorRight) {
@@ -1069,7 +1075,7 @@ var $;
         finally {
             $.$mol_fail = fail;
         }
-        $.$mol_fail(new Error('Not failed'));
+        $mol_fail(new Error('Not failed'));
     }
     $.$mol_assert_fail = $mol_assert_fail;
     function $mol_assert_equal(...args) {
@@ -1080,7 +1086,7 @@ var $;
                 if (Number.isNaN(args[i]) && Number.isNaN(args[j]))
                     continue;
                 if (args[i] !== args[j])
-                    $.$mol_fail(new Error(`Not equal (${i + 1}:${j + 1})\n${args[i]}\n${args[j]}`));
+                    $mol_fail(new Error(`Not equal (${i + 1}:${j + 1})\n${args[i]}\n${args[j]}`));
             }
         }
     }
@@ -1091,7 +1097,7 @@ var $;
                 if (i === j)
                     continue;
                 if (args[i] === args[j] || (Number.isNaN(args[i]) && Number.isNaN(args[j]))) {
-                    $.$mol_fail(new Error(`args[${i}] = args[${j}] = ${args[i]}`));
+                    $mol_fail(new Error(`args[${i}] = args[${j}] = ${args[i]}`));
                 }
             }
         }
@@ -1099,7 +1105,7 @@ var $;
     $.$mol_assert_unique = $mol_assert_unique;
     function $mol_assert_like(head, ...tail) {
         for (let [index, value] of Object.entries(tail)) {
-            if (!$.$mol_compare_deep(value, head)) {
+            if (!$mol_compare_deep(value, head)) {
                 const print = (val) => {
                     if (!val)
                         return val;
@@ -1115,217 +1121,217 @@ var $;
                         return val;
                     }
                 };
-                return $.$mol_fail(new Error(`Not like (1:${+index + 2})\n${print(head)}\n---\n${print(value)}`));
+                return $mol_fail(new Error(`Not like (1:${+index + 2})\n${print(head)}\n---\n${print(value)}`));
             }
         }
     }
     $.$mol_assert_like = $mol_assert_like;
     function $mol_assert_dom(left, right) {
-        $mol_assert_equal($.$mol_dom_serialize(left), $.$mol_dom_serialize(right));
+        $mol_assert_equal($mol_dom_serialize(left), $mol_dom_serialize(right));
     }
     $.$mol_assert_dom = $mol_assert_dom;
 })($ || ($ = {}));
-//assert.js.map
+//mol/assert/assert.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'equal paths'() {
-            const diff = $.$mol_diff_path([1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]);
-            $.$mol_assert_like(diff, {
+            const diff = $mol_diff_path([1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]);
+            $mol_assert_like(diff, {
                 prefix: [1, 2, 3, 4],
                 suffix: [[], [], []],
             });
         },
         'different suffix'() {
-            const diff = $.$mol_diff_path([1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 5, 4]);
-            $.$mol_assert_like(diff, {
+            const diff = $mol_diff_path([1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 5, 4]);
+            $mol_assert_like(diff, {
                 prefix: [1, 2],
                 suffix: [[3, 4], [3, 5], [5, 4]],
             });
         },
         'one contains other'() {
-            const diff = $.$mol_diff_path([1, 2, 3, 4], [1, 2], [1, 2, 3]);
-            $.$mol_assert_like(diff, {
+            const diff = $mol_diff_path([1, 2, 3, 4], [1, 2], [1, 2, 3]);
+            $mol_assert_like(diff, {
                 prefix: [1, 2],
                 suffix: [[3, 4], [], [3]],
             });
         },
         'fully different'() {
-            const diff = $.$mol_diff_path([1, 2], [3, 4], [5, 6]);
-            $.$mol_assert_like(diff, {
+            const diff = $mol_diff_path([1, 2], [3, 4], [5, 6]);
+            $mol_assert_like(diff, {
                 prefix: [],
                 suffix: [[1, 2], [3, 4], [5, 6]],
             });
         },
     });
 })($ || ($ = {}));
-//path.test.js.map
+//mol/diff/path/path.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is number'() {
-            $.$mol_data_number(0);
+            $mol_data_number(0);
         },
         'Is not number'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_number('x');
+            $mol_assert_fail(() => {
+                $mol_data_number('x');
             }, 'x is not a number');
         },
         'Is object number'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_number(new Number(''));
+            $mol_assert_fail(() => {
+                $mol_data_number(new Number(''));
             }, '0 is not a number');
         },
     });
 })($ || ($ = {}));
-//number.test.js.map
+//mol/data/number/number.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'config by value'() {
-            const N = $.$mol_data_setup((a) => a, 5);
-            $.$mol_assert_equal(N.config, 5);
+            const N = $mol_data_setup((a) => a, 5);
+            $mol_assert_equal(N.config, 5);
         },
     });
 })($ || ($ = {}));
-//setup.test.js.map
+//mol/data/setup/setup.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is empty array'() {
-            $.$mol_data_array($.$mol_data_number)([]);
+            $mol_data_array($mol_data_number)([]);
         },
         'Is array'() {
-            $.$mol_data_array($.$mol_data_number)([1, 2]);
+            $mol_data_array($mol_data_number)([1, 2]);
         },
         'Is not array'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_array($.$mol_data_number)({ [0]: 1, length: 1, map: () => { } });
+            $mol_assert_fail(() => {
+                $mol_data_array($mol_data_number)({ [0]: 1, length: 1, map: () => { } });
             }, '[object Object] is not an array');
         },
         'Has wrong item'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_array($.$mol_data_number)([1, '1']);
+            $mol_assert_fail(() => {
+                $mol_data_array($mol_data_number)([1, '1']);
             }, '[1] 1 is not a number');
         },
         'Has wrong deep item'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_array($.$mol_data_array($.$mol_data_number))([[], [0, 0, false]]);
+            $mol_assert_fail(() => {
+                $mol_data_array($mol_data_array($mol_data_number))([[], [0, 0, false]]);
             }, '[1] [2] false is not a number');
         },
     });
 })($ || ($ = {}));
-//array.test.js.map
+//mol/data/array/array.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is boolean - true'() {
-            $.$mol_data_boolean(true);
+            $mol_data_boolean(true);
         },
         'Is boolean - false'() {
-            $.$mol_data_boolean(false);
+            $mol_data_boolean(false);
         },
         'Is not boolean'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_boolean('x');
+            $mol_assert_fail(() => {
+                $mol_data_boolean('x');
             }, 'x is not a boolean');
         },
         'Is object boolean'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_boolean(new Boolean(''));
+            $mol_assert_fail(() => {
+                $mol_data_boolean(new Boolean(''));
             }, 'false is not a boolean');
         },
     });
 })($ || ($ = {}));
-//boolean.test.js.map
+//mol/data/boolean/boolean.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'is same number'() {
-            $.$mol_data_const(Number.NaN)(Number.NaN);
+            $mol_data_const(Number.NaN)(Number.NaN);
         },
         'is different number'() {
-            const Five = $.$mol_data_const(5);
-            $.$mol_assert_fail(() => Five(6), '6 is not 5');
+            const Five = $mol_data_const(5);
+            $mol_assert_fail(() => Five(6), '6 is not 5');
         },
     });
 })($ || ($ = {}));
-//const.test.js.map
+//mol/data/const/const.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is string'() {
-            $.$mol_data_string('');
+            $mol_data_string('');
         },
         'Is not string'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_string(0);
+            $mol_assert_fail(() => {
+                $mol_data_string(0);
             }, '0 is not a string');
         },
         'Is object string'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_string(new String('x'));
+            $mol_assert_fail(() => {
+                $mol_data_string(new String('x'));
             }, 'x is not a string');
         },
     });
 })($ || ($ = {}));
-//string.test.js.map
+//mol/data/string/string.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is fit'() {
-            $.$mol_data_pattern(/^-$/)('-');
+            $mol_data_pattern(/^-$/)('-');
         },
         'Is not fit'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_pattern(/^-$/)('+');
+            $mol_assert_fail(() => {
+                $mol_data_pattern(/^-$/)('+');
             }, '+ is not a /^-$/');
         },
     });
 })($ || ($ = {}));
-//pattern.test.js.map
+//mol/data/pattern/pattern.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is email'() {
-            $.$mol_data_email('foo@bar');
+            $mol_data_email('foo@bar');
         },
         'Has not host'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_email('foo@');
+            $mol_assert_fail(() => {
+                $mol_data_email('foo@');
             }, 'foo@ is not a /.+@.+/');
         },
         'Has not name'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_email('@bar');
+            $mol_assert_fail(() => {
+                $mol_data_email('@bar');
             }, '@bar is not a /.+@.+/');
         },
         'Has not @'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_email('foo.bar');
+            $mol_assert_fail(() => {
+                $mol_data_email('foo.bar');
             }, 'foo.bar is not a /.+@.+/');
         },
     });
 })($ || ($ = {}));
-//email.test.js.map
+//mol/data/email/email.test.ts
 ;
 "use strict";
 var $;
@@ -1335,28 +1341,28 @@ var $;
         sex[sex["male"] = 0] = "male";
         sex[sex["female"] = 1] = "female";
     })(sex || (sex = {}));
-    const Sex = $.$mol_data_enum('sex', sex);
-    $.$mol_test({
+    const Sex = $mol_data_enum('sex', sex);
+    $mol_test({
         'config of enum'() {
-            $.$mol_assert_like(Sex.config, {
+            $mol_assert_like(Sex.config, {
                 name: 'sex',
                 dict: sex,
             });
         },
         'name of enum'() {
-            $.$mol_assert_equal(Sex.config.name, 'sex');
+            $mol_assert_equal(Sex.config.name, 'sex');
         },
         'Is right value of enum'() {
-            $.$mol_assert_equal(Sex(0), sex.male);
+            $mol_assert_equal(Sex(0), sex.male);
         },
         'Is wrong value of enum'() {
-            $.$mol_assert_fail(() => Sex(2), `2 is not value of sex enum`);
+            $mol_assert_fail(() => Sex(2), `2 is not value of sex enum`);
         },
         'Is name instead of value'() {
-            $.$mol_assert_fail(() => Sex('male'), `male is not value of sex enum`);
+            $mol_assert_fail(() => Sex('male'), `male is not value of sex enum`);
         },
         'Is common object field'() {
-            $.$mol_assert_fail(() => Sex('__proto__'), `__proto__ is not value of sex enum`);
+            $mol_assert_fail(() => Sex('__proto__'), `__proto__ is not value of sex enum`);
         },
     });
     let gender;
@@ -1364,187 +1370,187 @@ var $;
         gender["bisexual"] = "bisexual";
         gender["trans"] = "transgender";
     })(gender || (gender = {}));
-    const Gender = $.$mol_data_enum('gender', gender);
-    $.$mol_test({
+    const Gender = $mol_data_enum('gender', gender);
+    $mol_test({
         'config of enum'() {
-            $.$mol_assert_like(Gender.config, {
+            $mol_assert_like(Gender.config, {
                 name: 'gender',
                 dict: gender,
             });
         },
         'Is right value of enum'() {
-            $.$mol_assert_equal(Gender('transgender'), gender.trans);
+            $mol_assert_equal(Gender('transgender'), gender.trans);
         },
         'Is wrong value of enum'() {
-            $.$mol_assert_fail(() => Gender('xxx'), `xxx is not value of gender enum`);
+            $mol_assert_fail(() => Gender('xxx'), `xxx is not value of gender enum`);
         },
         'Is name instead of value'() {
-            $.$mol_assert_fail(() => Gender('trans'), `trans is not value of gender enum`);
+            $mol_assert_fail(() => Gender('trans'), `trans is not value of gender enum`);
         },
         'Is common object field'() {
-            $.$mol_assert_fail(() => Gender('__proto__'), `__proto__ is not value of gender enum`);
+            $mol_assert_fail(() => Gender('__proto__'), `__proto__ is not value of gender enum`);
         },
     });
 })($ || ($ = {}));
-//enum.test.js.map
+//mol/data/enum/enum.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is same class'() {
-            $.$mol_data_instance(Date)(new Date);
+            $mol_data_instance(Date)(new Date);
         },
         'Is sub class'() {
-            $.$mol_data_instance(Object)(new Date);
+            $mol_data_instance(Object)(new Date);
         },
         'Is super class'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_instance(Date)(new Object);
+            $mol_assert_fail(() => {
+                $mol_data_instance(Date)(new Object);
             }, '[object Object] is not a Date');
         },
         'Is another class'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_instance(Date)(new Array);
+            $mol_assert_fail(() => {
+                $mol_data_instance(Date)(new Array);
             }, ' is not a Date');
         },
         'Is not object'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_instance(Date)(null);
+            $mol_assert_fail(() => {
+                $mol_data_instance(Date)(null);
             }, 'null is not a Date');
         },
     });
 })($ || ($ = {}));
-//instance.test.js.map
+//mol/data/instance/instance.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is integer'() {
-            $.$mol_data_integer(0);
+            $mol_data_integer(0);
         },
         'Is float'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_integer(1.1);
+            $mol_assert_fail(() => {
+                $mol_data_integer(1.1);
             }, '1.1 is not an integer');
         },
     });
 })($ || ($ = {}));
-//integer.test.js.map
+//mol/data/integer/integer.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Nominal typing'() {
-            const Weight = $.$mol_data_nominal({ Weight: $.$mol_data_integer });
-            const Length = $.$mol_data_nominal({ Length: $.$mol_data_integer });
+            const Weight = $mol_data_nominal({ Weight: $mol_data_integer });
+            const Length = $mol_data_nominal({ Length: $mol_data_integer });
             let len = Length(10);
             len = Length(20);
             len = 20;
         },
     });
 })($ || ($ = {}));
-//nominal.test.js.map
+//mol/data/nominal/nominal.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is null'() {
-            $.$mol_data_nullable($.$mol_data_number)(null);
+            $mol_data_nullable($mol_data_number)(null);
         },
         'Is not null'() {
-            $.$mol_data_nullable($.$mol_data_number)(0);
+            $mol_data_nullable($mol_data_number)(0);
         },
         'Is undefined'() {
-            $.$mol_assert_fail(() => {
-                const Type = $.$mol_data_nullable($.$mol_data_number);
+            $mol_assert_fail(() => {
+                const Type = $mol_data_nullable($mol_data_number);
                 Type(undefined);
             }, 'undefined is not a number');
         },
     });
 })($ || ($ = {}));
-//nullable.test.js.map
+//mol/data/nullable/nullable.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    const Age = $.$mol_data_optional($.$mol_data_number);
-    const Age_or_zero = $.$mol_data_optional($.$mol_data_number, () => 0);
-    $.$mol_test({
+    const Age = $mol_data_optional($mol_data_number);
+    const Age_or_zero = $mol_data_optional($mol_data_number, () => 0);
+    $mol_test({
         'Is not present'() {
-            $.$mol_assert_equal(Age(undefined), undefined);
+            $mol_assert_equal(Age(undefined), undefined);
         },
         'Is present'() {
-            $.$mol_assert_equal(Age(0), 0);
+            $mol_assert_equal(Age(0), 0);
         },
         'Fallbacked'() {
-            $.$mol_assert_equal(Age_or_zero(undefined), 0);
+            $mol_assert_equal(Age_or_zero(undefined), 0);
         },
         'Is null'() {
-            $.$mol_assert_fail(() => Age(null), 'null is not a number');
+            $mol_assert_fail(() => Age(null), 'null is not a number');
         },
     });
 })($ || ($ = {}));
-//optional.test.js.map
+//mol/data/optional/optional.test.ts
 ;
 "use strict";
-//equals.test.js.map
+//mol/type/equals/equals.test.ts
 ;
 "use strict";
-//merge.test.js.map
+//mol/type/merge/merge.test.ts
 ;
 "use strict";
-//undefined.test.js.map
+//mol/type/partial/undefined/undefined.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Fit to record'() {
-            const User = $.$mol_data_record({ age: $.$mol_data_number });
+            const User = $mol_data_record({ age: $mol_data_number });
             User({ age: 0 });
         },
         'Extends record'() {
-            const User = $.$mol_data_record({ age: $.$mol_data_number });
+            const User = $mol_data_record({ age: $mol_data_number });
             User({ age: 0, name: 'Jin' });
         },
         'Shrinks record'() {
-            $.$mol_assert_fail(() => {
-                const User = $.$mol_data_record({ age: $.$mol_data_number, name: $.$mol_data_string });
+            $mol_assert_fail(() => {
+                const User = $mol_data_record({ age: $mol_data_number, name: $mol_data_string });
                 User({ age: 0 });
             }, '["name"] undefined is not a string');
         },
         'Shrinks deep record'() {
-            $.$mol_assert_fail(() => {
-                const User = $.$mol_data_record({ wife: $.$mol_data_record({ age: $.$mol_data_number }) });
+            $mol_assert_fail(() => {
+                const User = $mol_data_record({ wife: $mol_data_record({ age: $mol_data_number }) });
                 User({ wife: {} });
             }, '["wife"] ["age"] undefined is not a number');
         },
     });
 })($ || ($ = {}));
-//record.test.js.map
+//mol/data/record/record.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'Is first'() {
-            $.$mol_data_variant($.$mol_data_number, $.$mol_data_string)(0);
+            $mol_data_variant($mol_data_number, $mol_data_string)(0);
         },
         'Is second'() {
-            $.$mol_data_variant($.$mol_data_number, $.$mol_data_string)('');
+            $mol_data_variant($mol_data_number, $mol_data_string)('');
         },
         'Is false'() {
-            $.$mol_assert_fail(() => {
-                $.$mol_data_variant($.$mol_data_number, $.$mol_data_string)(false);
+            $mol_assert_fail(() => {
+                $mol_data_variant($mol_data_number, $mol_data_string)(false);
             }, 'false is not any of variants\nfalse is not a number\nfalse is not a string');
         },
     });
 })($ || ($ = {}));
-//variant.test.js.map
+//mol/data/variant/variant.test.ts
 ;
 "use strict";
 var $;
@@ -1579,36 +1585,36 @@ var $;
     }
     $.$mol_time_base = $mol_time_base;
 })($ || ($ = {}));
-//base.js.map
+//mol/time/base/base.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'parse and serial'() {
-            $.$mol_assert_equal(new $.$mol_time_duration('P42.1Y').toString(), 'P42.1YT');
-            $.$mol_assert_equal(new $.$mol_time_duration('P42.1M').toString(), 'P42.1MT');
-            $.$mol_assert_equal(new $.$mol_time_duration('P42.1D').toString(), 'P42.1DT');
-            $.$mol_assert_equal(new $.$mol_time_duration('PT42.1h').toString(), 'PT42.1H');
-            $.$mol_assert_equal(new $.$mol_time_duration('PT42.1m').toString(), 'PT42.1M');
-            $.$mol_assert_equal(new $.$mol_time_duration('PT42.1s').toString(), 'PT42.1S');
-            $.$mol_assert_equal(new $.$mol_time_duration('P1Y2M3DT4h5m6.7s').toString(), 'P1Y2M3DT4H5M6.7S');
+            $mol_assert_equal(new $mol_time_duration('P42.1Y').toString(), 'P42.1YT');
+            $mol_assert_equal(new $mol_time_duration('P42.1M').toString(), 'P42.1MT');
+            $mol_assert_equal(new $mol_time_duration('P42.1D').toString(), 'P42.1DT');
+            $mol_assert_equal(new $mol_time_duration('PT42.1h').toString(), 'PT42.1H');
+            $mol_assert_equal(new $mol_time_duration('PT42.1m').toString(), 'PT42.1M');
+            $mol_assert_equal(new $mol_time_duration('PT42.1s').toString(), 'PT42.1S');
+            $mol_assert_equal(new $mol_time_duration('P1Y2M3DT4h5m6.7s').toString(), 'P1Y2M3DT4H5M6.7S');
         },
         'format typed'() {
-            $.$mol_assert_equal(new $.$mol_time_duration('P1Y2M3DT4h5m6s').toString('P#Y#M#DT#h#m#s'), 'P1Y2M3DT4H5M6S');
+            $mol_assert_equal(new $mol_time_duration('P1Y2M3DT4h5m6s').toString('P#Y#M#DT#h#m#s'), 'P1Y2M3DT4H5M6S');
         },
         'comparison'() {
             const iso = 'P1Y1M1DT1h1m1s';
-            $.$mol_assert_like(new $.$mol_time_duration(iso), new $.$mol_time_duration(iso));
+            $mol_assert_like(new $mol_time_duration(iso), new $mol_time_duration(iso));
         },
     });
 })($ || ($ = {}));
-//duration.test.js.map
+//mol/time/duration/duration.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    class $mol_time_duration extends $.$mol_time_base {
+    class $mol_time_duration extends $mol_time_base {
         constructor(config = 0) {
             super();
             if (typeof config === 'number') {
@@ -1738,64 +1744,64 @@ var $;
     }
     $.$mol_time_duration = $mol_time_duration;
 })($ || ($ = {}));
-//duration.js.map
+//mol/time/duration/duration.ts
 ;
 "use strict";
-//param.test.js.map
+//mol/type/param/param.test.ts
 ;
 "use strict";
-//tail.test.js.map
+//mol/type/tail/tail.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'function'() {
-            $.$mol_assert_not($.$mol_func_is_class(function () { }));
+            $mol_assert_not($mol_func_is_class(function () { }));
         },
         'generator'() {
-            $.$mol_assert_not($.$mol_func_is_class(function* () { }));
+            $mol_assert_not($mol_func_is_class(function* () { }));
         },
         'async'() {
-            $.$mol_assert_not($.$mol_func_is_class(async function () { }));
+            $mol_assert_not($mol_func_is_class(async function () { }));
         },
         'arrow'() {
-            $.$mol_assert_not($.$mol_func_is_class(() => null));
+            $mol_assert_not($mol_func_is_class(() => null));
         },
         'named class'() {
-            $.$mol_assert_ok($.$mol_func_is_class(class Foo {
+            $mol_assert_ok($mol_func_is_class(class Foo {
             }));
         },
         'unnamed class'() {
-            $.$mol_assert_ok($.$mol_func_is_class(class {
+            $mol_assert_ok($mol_func_is_class(class {
             }));
         },
     });
 })($ || ($ = {}));
-//class.test.js.map
+//mol/func/is/class/class.test.ts
 ;
 "use strict";
-//result.test.js.map
+//mol/type/result/result.test.ts
 ;
 "use strict";
-//foot.test.js.map
+//mol/type/foot/foot.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'single function'() {
-            const stringify = $.$mol_data_pipe((input) => input.toString());
-            $.$mol_assert_equal(stringify(5), '5');
+            const stringify = $mol_data_pipe((input) => input.toString());
+            $mol_assert_equal(stringify(5), '5');
         },
         'two functions'() {
-            const isLong = $.$mol_data_pipe((input) => input.toString(), (input) => input.length > 2);
-            $.$mol_assert_equal(isLong(5.0), false);
-            $.$mol_assert_equal(isLong(5.1), true);
+            const isLong = $mol_data_pipe((input) => input.toString(), (input) => input.length > 2);
+            $mol_assert_equal(isLong(5.0), false);
+            $mol_assert_equal(isLong(5.1), true);
         },
         'three functions'() {
-            const pattern = $.$mol_data_pipe((input) => input.toString(), (input) => new RegExp(input), (input) => input.toString());
-            $.$mol_assert_equal(pattern(5), '/5/');
+            const pattern = $mol_data_pipe((input) => input.toString(), (input) => new RegExp(input), (input) => input.toString());
+            $mol_assert_equal(pattern(5), '/5/');
         },
         'classes'() {
             class Box {
@@ -1804,26 +1810,26 @@ var $;
                     this.value = value;
                 }
             }
-            const boxify = $.$mol_data_pipe((input) => input.toString(), Box);
-            $.$mol_assert_ok(boxify(5) instanceof Box);
-            $.$mol_assert_like(boxify(5).value, '5');
+            const boxify = $mol_data_pipe((input) => input.toString(), Box);
+            $mol_assert_ok(boxify(5) instanceof Box);
+            $mol_assert_like(boxify(5).value, '5');
         },
     });
 })($ || ($ = {}));
-//pipe.test.js.map
+//mol/data/pipe/pipe.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         '(De)Serialization'() {
-            const Duration = $.$mol_data_wrapper($.$mol_data_variant($.$mol_data_string, $.$mol_data_integer), $.$mol_time_duration);
-            $.$mol_assert_equal(JSON.stringify(Duration('P1D')), '"P1DT"');
-            $.$mol_assert_equal(JSON.stringify(Duration(1000)), '"PT1S"');
+            const Duration = $mol_data_wrapper($mol_data_variant($mol_data_string, $mol_data_integer), $mol_time_duration);
+            $mol_assert_equal(JSON.stringify(Duration('P1D')), '"P1DT"');
+            $mol_assert_equal(JSON.stringify(Duration(1000)), '"PT1S"');
         },
     });
 })($ || ($ = {}));
-//wrapper.test.js.map
+//mol/data/wrapper/wrapper.test.ts
 ;
 "use strict";
 var $;
@@ -1847,7 +1853,7 @@ var $;
     $.$mol_log3_area_lazy = $mol_log3_area_lazy;
     $.$mol_log3_stack = [];
 })($ || ($ = {}));
-//log3.js.map
+//mol/log3/log3.ts
 ;
 "use strict";
 var $;
@@ -1875,12 +1881,12 @@ var $;
     $.$mol_log3_rise = $mol_log3_node_make('log', 'stdout', 'rise', 'magenta');
     $.$mol_log3_area = $mol_log3_node_make('log', 'stdout', 'area', 'cyan');
 })($ || ($ = {}));
-//log3.node.js.map
+//mol/log3/log3.node.ts
 ;
 "use strict";
 var $;
 (function ($_1) {
-    $_1.$mol_test_mocks.push($ => {
+    $mol_test_mocks.push($ => {
         $.$mol_log3_come = () => { };
         $.$mol_log3_done = () => { };
         $.$mol_log3_fail = () => { };
@@ -1889,7 +1895,7 @@ var $;
         $.$mol_log3_area = () => () => { };
     });
 })($ || ($ = {}));
-//log3.test.js.map
+//mol/log3/log3.test.ts
 ;
 "use strict";
 var $;
@@ -1899,7 +1905,7 @@ var $;
     }
     $.$mol_env = $mol_env;
 })($ || ($ = {}));
-//env.js.map
+//mol/env/env.ts
 ;
 "use strict";
 var $;
@@ -1908,7 +1914,7 @@ var $;
         return this.process.env;
     };
 })($ || ($ = {}));
-//env.node.js.map
+//mol/env/env.node.ts
 ;
 "use strict";
 var $;
@@ -1928,14 +1934,14 @@ var $;
             env: this.$mol_env(),
         });
         if (res.status || res.error)
-            return $.$mol_fail(res.error || new Error(res.stderr.toString()));
+            return $mol_fail(res.error || new Error(res.stderr.toString()));
         if (!res.stdout)
             res.stdout = Buffer.from([]);
         return res;
     }
     $.$mol_exec = $mol_exec;
 })($ || ($ = {}));
-//exec.node.js.map
+//mol/exec/exec.node.ts
 ;
 "use strict";
 var $;
@@ -1946,29 +1952,29 @@ var $;
     }
     $.$mol_ambient = $mol_ambient;
 })($ || ($ = {}));
-//ambient.js.map
+//mol/ambient/ambient.ts
 ;
 "use strict";
 var $;
 (function ($) {
-    $.$mol_test({
+    $mol_test({
         'get'() {
-            const proxy = $.$mol_delegate({}, () => ({ foo: 777 }));
-            $.$mol_assert_equal(proxy.foo, 777);
+            const proxy = $mol_delegate({}, () => ({ foo: 777 }));
+            $mol_assert_equal(proxy.foo, 777);
         },
         'has'() {
-            const proxy = $.$mol_delegate({}, () => ({ foo: 777 }));
-            $.$mol_assert_equal('foo' in proxy, true);
+            const proxy = $mol_delegate({}, () => ({ foo: 777 }));
+            $mol_assert_equal('foo' in proxy, true);
         },
         'set'() {
             const target = { foo: 777 };
-            const proxy = $.$mol_delegate({}, () => target);
+            const proxy = $mol_delegate({}, () => target);
             proxy.foo = 123;
-            $.$mol_assert_equal(target.foo, 123);
+            $mol_assert_equal(target.foo, 123);
         },
         'getOwnPropertyDescriptor'() {
-            const proxy = $.$mol_delegate({}, () => ({ foo: 777 }));
-            $.$mol_assert_like(Object.getOwnPropertyDescriptor(proxy, 'foo'), {
+            const proxy = $mol_delegate({}, () => ({ foo: 777 }));
+            $mol_assert_like(Object.getOwnPropertyDescriptor(proxy, 'foo'), {
                 value: 777,
                 writable: true,
                 enumerable: true,
@@ -1976,40 +1982,40 @@ var $;
             });
         },
         'ownKeys'() {
-            const proxy = $.$mol_delegate({}, () => ({ foo: 777, [Symbol.toStringTag]: 'bar' }));
-            $.$mol_assert_like(Reflect.ownKeys(proxy), ['foo', Symbol.toStringTag]);
+            const proxy = $mol_delegate({}, () => ({ foo: 777, [Symbol.toStringTag]: 'bar' }));
+            $mol_assert_like(Reflect.ownKeys(proxy), ['foo', Symbol.toStringTag]);
         },
         'getPrototypeOf'() {
             class Foo {
             }
-            const proxy = $.$mol_delegate({}, () => new Foo);
-            $.$mol_assert_equal(Object.getPrototypeOf(proxy), Foo.prototype);
+            const proxy = $mol_delegate({}, () => new Foo);
+            $mol_assert_equal(Object.getPrototypeOf(proxy), Foo.prototype);
         },
         'setPrototypeOf'() {
             class Foo {
             }
             const target = {};
-            const proxy = $.$mol_delegate({}, () => target);
+            const proxy = $mol_delegate({}, () => target);
             Object.setPrototypeOf(proxy, Foo.prototype);
-            $.$mol_assert_equal(Object.getPrototypeOf(target), Foo.prototype);
+            $mol_assert_equal(Object.getPrototypeOf(target), Foo.prototype);
         },
         'instanceof'() {
             class Foo {
             }
-            const proxy = $.$mol_delegate({}, () => new Foo);
-            $.$mol_assert_ok(proxy instanceof Foo);
-            $.$mol_assert_ok(proxy instanceof $.$mol_delegate);
+            const proxy = $mol_delegate({}, () => new Foo);
+            $mol_assert_ok(proxy instanceof Foo);
+            $mol_assert_ok(proxy instanceof $mol_delegate);
         },
         'autobind'() {
             class Foo {
             }
-            const proxy = $.$mol_delegate({}, () => new Foo);
-            $.$mol_assert_ok(proxy instanceof Foo);
-            $.$mol_assert_ok(proxy instanceof $.$mol_delegate);
+            const proxy = $mol_delegate({}, () => new Foo);
+            $mol_assert_ok(proxy instanceof Foo);
+            $mol_assert_ok(proxy instanceof $mol_delegate);
         },
     });
 })($ || ($ = {}));
-//delegate.test.js.map
+//mol/delegate/delegate.test.ts
 ;
 "use strict";
 var $;
@@ -2046,7 +2052,7 @@ var $;
         value: (obj) => instances.has(obj),
     });
 })($ || ($ = {}));
-//delegate.js.map
+//mol/delegate/delegate.ts
 ;
 "use strict";
 var $;
@@ -2058,7 +2064,7 @@ var $;
                 return false;
             if (typeof having !== 'object')
                 return false;
-            if (having instanceof $.$mol_delegate)
+            if (having instanceof $mol_delegate)
                 return false;
             if (typeof having['destructor'] !== 'function')
                 return false;
@@ -2102,30 +2108,30 @@ var $;
     }
     $.$mol_owning_catch = $mol_owning_catch;
 })($ || ($ = {}));
-//owning.js.map
+//mol/owning/owning.ts
 ;
 "use strict";
-//writable.test.js.map
+//mol/type/writable/writable.test.ts
 ;
 "use strict";
-//writable.js.map
+//mol/type/writable/writable.ts
 ;
 "use strict";
 var $;
 (function ($) {
     class $mol_object2 {
         static $ = $;
-        [$.$mol_ambient_ref] = null;
+        [$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?.$ || $mol_object2.$;
+            if (this[$mol_ambient_ref])
+                return this[$mol_ambient_ref];
+            const owner = $mol_owning_get(this);
+            return this[$mol_ambient_ref] = owner?.$ || $mol_object2.$;
         }
         set $(next) {
-            if (this[$.$mol_ambient_ref])
-                $.$mol_fail_hidden(new Error('Context already defined'));
-            this[$.$mol_ambient_ref] = 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;
@@ -2151,7 +2157,7 @@ var $;
     }
     $.$mol_object2 = $mol_object2;
 })($ || ($ = {}));
-//object2.js.map
+//mol/object2/object2.ts
 ;
 "use strict";
 var $;
@@ -2162,7 +2168,7 @@ var $;
             let warned = false;
             descr.value = function $mol_deprecated_wrapper(...args) {
                 if (!warned) {
-                    $.$$.$mol_log3_warn({
+                    $$.$mol_log3_warn({
                         place: `${host.constructor.name}::${field}`,
                         message: `Deprecated`,
                         hint: message,
@@ -2175,54 +2181,54 @@ var $;
     }
     $.$mol_deprecated = $mol_deprecated;
 })($ || ($ = {}));
-//deprecated.js.map
+//mol/deprecated/deprecated.ts
 ;
 "use strict";
 var $;
 (function ($_1) {
-    $_1.$mol_test({
+    $mol_test({
         'tree parsing'() {
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("foo\nbar\n").sub.length, 2);
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("foo\nbar\n").sub[1].type, "bar");
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("foo\n\n\n").sub.length, 1);
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("=foo\n\\bar\n").sub.length, 2);
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("=foo\n\\bar\n").sub[1].data, "bar");
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("foo bar \\pol").sub[0].sub[0].sub[0].data, "pol");
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString("foo bar\n\t\\pol\n\t\\men").sub[0].sub[0].sub[1].data, "men");
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('foo bar \\text\n').toString(), 'foo bar \\text\n');
+            $mol_assert_equal($mol_tree.fromString("foo\nbar\n").sub.length, 2);
+            $mol_assert_equal($mol_tree.fromString("foo\nbar\n").sub[1].type, "bar");
+            $mol_assert_equal($mol_tree.fromString("foo\n\n\n").sub.length, 1);
+            $mol_assert_equal($mol_tree.fromString("=foo\n\\bar\n").sub.length, 2);
+            $mol_assert_equal($mol_tree.fromString("=foo\n\\bar\n").sub[1].data, "bar");
+            $mol_assert_equal($mol_tree.fromString("foo bar \\pol").sub[0].sub[0].sub[0].data, "pol");
+            $mol_assert_equal($mol_tree.fromString("foo bar\n\t\\pol\n\t\\men").sub[0].sub[0].sub[1].data, "men");
+            $mol_assert_equal($mol_tree.fromString('foo bar \\text\n').toString(), 'foo bar \\text\n');
         },
         'inserting'() {
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('a b c d').insert(new $_1.$mol_tree, 'a', 'b', 'c').toString(), 'a b \\\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('a b').insert(new $_1.$mol_tree, 'a', 'b', 'c', 'd').toString(), 'a b c \\\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('a b c d').insert(new $_1.$mol_tree, 0, 0, 0).toString(), 'a b \\\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('a b').insert(new $_1.$mol_tree, 0, 0, 0, 0).toString(), 'a b \\\n\t\\\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('a b c d').insert(new $_1.$mol_tree, null, null, null).toString(), 'a b \\\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromString('a b').insert(new $_1.$mol_tree, null, null, null, null).toString(), 'a b \\\n\t\\\n');
+            $mol_assert_equal($mol_tree.fromString('a b c d').insert(new $mol_tree, 'a', 'b', 'c').toString(), 'a b \\\n');
+            $mol_assert_equal($mol_tree.fromString('a b').insert(new $mol_tree, 'a', 'b', 'c', 'd').toString(), 'a b c \\\n');
+            $mol_assert_equal($mol_tree.fromString('a b c d').insert(new $mol_tree, 0, 0, 0).toString(), 'a b \\\n');
+            $mol_assert_equal($mol_tree.fromString('a b').insert(new $mol_tree, 0, 0, 0, 0).toString(), 'a b \\\n\t\\\n');
+            $mol_assert_equal($mol_tree.fromString('a b c d').insert(new $mol_tree, null, null, null).toString(), 'a b \\\n');
+            $mol_assert_equal($mol_tree.fromString('a b').insert(new $mol_tree, null, null, null, null).toString(), 'a b \\\n\t\\\n');
         },
         'fromJSON'() {
-            $_1.$mol_assert_equal($_1.$mol_tree.fromJSON([]).toString(), '/\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromJSON([false, true]).toString(), '/\n\tfalse\n\ttrue\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromJSON([0, 1, 2.3]).toString(), '/\n\t0\n\t1\n\t2.3\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromJSON(['', 'foo', 'bar\nbaz']).toString(), '/\n\t\\\n\t\\foo\n\t\\\n\t\t\\bar\n\t\t\\baz\n');
-            $_1.$mol_assert_equal($_1.$mol_tree.fromJSON({ 'foo': false, 'bar\nbaz': 'lol' }).toString(), '*\n\tfoo false\n\t\\\n\t\t\\bar\n\t\t\\baz\n\t\t\\lol\n');
+            $mol_assert_equal($mol_tree.fromJSON([]).toString(), '/\n');
+            $mol_assert_equal($mol_tree.fromJSON([false, true]).toString(), '/\n\tfalse\n\ttrue\n');
+            $mol_assert_equal($mol_tree.fromJSON([0, 1, 2.3]).toString(), '/\n\t0\n\t1\n\t2.3\n');
+            $mol_assert_equal($mol_tree.fromJSON(['', 'foo', 'bar\nbaz']).toString(), '/\n\t\\\n\t\\foo\n\t\\\n\t\t\\bar\n\t\t\\baz\n');
+            $mol_assert_equal($mol_tree.fromJSON({ 'foo': false, 'bar\nbaz': 'lol' }).toString(), '*\n\tfoo false\n\t\\\n\t\t\\bar\n\t\t\\baz\n\t\t\\lol\n');
         },
         'toJSON'() {
-            $_1.$mol_assert_equal(JSON.stringify($_1.$mol_tree.fromString('/\n').sub[0]), '[]');
-            $_1.$mol_assert_equal(JSON.stringify($_1.$mol_tree.fromString('/\n\tfalse\n\ttrue\n').sub[0]), '[false,true]');
-            $_1.$mol_assert_equal(JSON.stringify($_1.$mol_tree.fromString('/\n\t0\n\t1\n\t2.3\n').sub[0]), '[0,1,2.3]');
-            $_1.$mol_assert_equal(JSON.stringify($_1.$mol_tree.fromString('/\n\t\\\n\t\\foo\n\t\\\n\t\t\\bar\n\t\t\\baz\n').sub[0]), '["","foo","bar\\nbaz"]');
-            $_1.$mol_assert_equal(JSON.stringify($_1.$mol_tree.fromString('*\n\tfoo false\n\t\\\n\t\t\\bar\n\t\t\\baz\n\t\t\\lol\n').sub[0]), '{"foo":false,"bar\\nbaz":"lol"}');
+            $mol_assert_equal(JSON.stringify($mol_tree.fromString('/\n').sub[0]), '[]');
+            $mol_assert_equal(JSON.stringify($mol_tree.fromString('/\n\tfalse\n\ttrue\n').sub[0]), '[false,true]');
+            $mol_assert_equal(JSON.stringify($mol_tree.fromString('/\n\t0\n\t1\n\t2.3\n').sub[0]), '[0,1,2.3]');
+            $mol_assert_equal(JSON.stringify($mol_tree.fromString('/\n\t\\\n\t\\foo\n\t\\\n\t\t\\bar\n\t\t\\baz\n').sub[0]), '["","foo","bar\\nbaz"]');
+            $mol_assert_equal(JSON.stringify($mol_tree.fromString('*\n\tfoo false\n\t\\\n\t\t\\bar\n\t\t\\baz\n\t\t\\lol\n').sub[0]), '{"foo":false,"bar\\nbaz":"lol"}');
         },
         'hack'() {
-            const res = $_1.$mol_tree.fromString(`foo bar xxx`).hack({
+            const res = $mol_tree.fromString(`foo bar xxx`).hack({
                 '': (tree, context) => [tree.hack(context)],
                 'bar': (tree, context) => [tree.hack(context).clone({ type: '777' })],
             });
-            $_1.$mol_assert_equal(res.toString(), new $_1.$mol_tree({ type: 'foo 777 xxx' }).toString());
+            $mol_assert_equal(res.toString(), new $mol_tree({ type: 'foo 777 xxx' }).toString());
         },
         'errors handling'($) {
             const errors = [];
-            class Tree extends $_1.$mol_tree {
+            class Tree extends $mol_tree {
                 static $ = $.$mol_ambient({
                     $mol_fail: error => errors.push(error.message)
                 });
@@ -2231,17 +2237,17 @@ var $;
 				\t \tfoo
 				bar \\data
 			`, 'test');
-            $_1.$mol_assert_like(errors, ['Syntax error at test:2\n \tfoo']);
+            $mol_assert_like(errors, ['Syntax error at test:2\n \tfoo']);
         },
     });
 })($ || ($ = {}));
-//tree.test.js.map
+//mol/tree/tree.test.ts
 ;
 "use strict";
 var $;
 (function ($) {
     $.$mol_tree_convert = Symbol('$mol_tree_convert');
-    class $mol_tree extends $.$mol_object2 {
+    class $mol_tree extends $mol_object2 {
         type;
         data;
         sub;
@@ -2554,7 +2560,7 @@ var $;
             const sub = [].concat(...this.sub.map(child => {
                 const handle = context[child.type] || context[''];
                 if (!handle)
-                    $.$mol_fail(child.error('Handler not defined'));
+                    $mol_fail(child.error('Handler not defined'));
                 return handle(child, context);
             }));
             return this.clone({ sub });
@@ -2564,10 +2570,10 @@ var $;
         }
     }
     __decorate([
-        $.$mol_deprecated('Use $mol_tree:hack')
+        $mol_deprecated('Use $mol_tree:hack')
     ], $mol_tree.prototype, "transform", null);
     $.$mol_tree = $mol_tree;
 })($ || ($ = {}));
-//tree.js.map
+//mol/tree/tree.ts
 
 //# sourceMappingURL=node.test.js.map