mol_vary 0.0.69 → 0.0.71

package/node.mjs

@@ -222,6 +222,20 @@ var $;
 ;
 "use strict";
 
+;
+"use strict";
+var $;
+(function ($) {
+    const mod = require('module');
+    const internals = mod.builtinModules;
+    function $node_internal_check(name) {
+        if (name.startsWith('node:'))
+            return true;
+        return internals.includes(name);
+    }
+    $.$node_internal_check = $node_internal_check;
+})($ || ($ = {}));
+
 ;
 "use strict";
 var $;
@@ -301,39 +315,44 @@ var $node = new Proxy({ require }, {
     get(target, name, wrapper) {
         if (target[name])
             return target[name];
-        if (name.startsWith('node:'))
+        const $$ = $;
+        if ($$.$node_internal_check(name, target))
             return target.require(name);
         if (name[0] === '.')
             return target.require(name);
-        const mod = target.require('module');
-        if (mod.builtinModules.indexOf(name) >= 0)
-            return target.require(name);
         try {
             target.require.resolve(name);
         }
         catch {
-            const $$ = $;
-            $$.$mol_exec('.', 'npm', 'install', '--omit=dev', name);
+            try {
+                $$.$mol_exec('.', 'npm', 'install', '--omit=dev', name);
+            }
+            catch (e) {
+                if ($$.$mol_promise_like(e))
+                    $$.$mol_fail_hidden(e);
+            }
             try {
                 $$.$mol_exec('.', 'npm', 'install', '--omit=dev', '@types/' + name);
             }
             catch (e) {
-                if ($$.$mol_fail_catch(e)) {
-                    $$.$mol_fail_log(e);
-                }
+                if ($$.$mol_promise_like(e))
+                    $$.$mol_fail_hidden(e);
+                $$.$mol_fail_log(e);
             }
         }
         try {
             return target.require(name);
         }
         catch (error) {
-            if ($.$mol_fail_catch(error) && error.code === 'ERR_REQUIRE_ESM') {
+            if ($$.$mol_promise_like(error))
+                $$.$mol_fail_hidden(error);
+            if (error && typeof error === 'object' && error.code === 'ERR_REQUIRE_ESM') {
                 const module = cache.get(name);
                 if (module)
                     return module;
                 throw Object.assign(import(name).then(module => cache.set(name, module)), { cause: error });
             }
-            $.$mol_fail_log(error);
+            $$.$mol_fail_log(error);
             return null;
         }
     },
@@ -2548,8 +2567,8 @@ var $;
                 if (stack.includes(val))
                     $mol_fail(new Error('Cyclic refs', { cause: { stack, val } }));
                 stack.push(val);
-                for (const item of val)
-                    dump(item);
+                for (let i = 0; i < val.length; ++i)
+                    dump(val[i]);
                 if (stack.at(-1) !== val)
                     $mol_fail(new Error('Broken stack', { cause: { stack, val } }));
                 stack.pop();
@@ -2569,65 +2588,67 @@ var $;
                 const offset = offsets.get(val);
                 if (offset !== undefined)
                     return dump_unum($mol_vary_tip.link, offset);
-                const [keys, vals] = this.lean_find(val)?.(val) ?? [shape(val), Object.values(val)];
+                const { 0: keys, 1: vals } = this.lean_find(val)?.(val) ?? [shape(val), Object.values(val)];
                 dump_unum($mol_vary_tip.tupl, vals.length);
                 acquire((vals.length + 1) * 9);
                 dump_list(keys);
                 if (stack.includes(val))
                     $mol_fail(new Error('Cyclic refs', { cause: { stack, val } }));
                 stack.push(val);
-                for (const item of vals)
-                    dump(item);
+                for (let i = 0; i < vals.length; ++i)
+                    dump(vals[i]);
                 if (stack.at(-1) !== val)
                     $mol_fail(new Error('Broken stack', { cause: { stack, val } }));
                 stack.pop();
                 offsets.set(val, offsets.size);
             };
-            const dump = (val) => {
-                switch (typeof val) {
-                    case 'undefined': {
-                        this.array[pos++] = $mol_vary_spec.both;
-                        release(8);
-                        return;
-                    }
-                    case 'boolean': {
-                        this.array[pos++] = val ? $mol_vary_spec.true : $mol_vary_spec.fake;
-                        release(8);
-                        return;
+            const dumpers = {
+                undefined: () => {
+                    this.array[pos++] = $mol_vary_spec.both;
+                    capacity -= 8;
+                },
+                boolean: val => {
+                    this.array[pos++] = val ? $mol_vary_spec.true : $mol_vary_spec.fake;
+                    capacity -= 8;
+                },
+                number: val => {
+                    if (!Number.isInteger(val))
+                        dump_float(val);
+                    else
+                        dumpers.bigint(val);
+                },
+                bigint: val => {
+                    if (val < 0) {
+                        dump_snum(val);
                     }
-                    case 'number': {
-                        if (!Number.isInteger(val))
-                            return dump_float(val);
-                    }
-                    case 'bigint': {
-                        if (val < 0) {
-                            dump_snum(val);
-                        }
-                        else {
-                            dump_unum($mol_vary_tip.uint, val);
-                        }
-                        return;
+                    else {
+                        dump_unum($mol_vary_tip.uint, val);
                     }
-                    case 'string': return dump_string(val);
-                    case 'object': {
-                        if (!val) {
-                            release(8);
-                            return this.array[pos++] = $mol_vary_spec.none;
-                        }
-                        if (ArrayBuffer.isView(val))
-                            return dump_buffer(val);
-                        if (Array.isArray(val))
-                            return dump_list(val);
-                        return dump_object(val);
+                },
+                string: val => dump_string(val),
+                object: val => {
+                    if (!val) {
+                        capacity -= 8;
+                        return this.array[pos++] = $mol_vary_spec.none;
                     }
+                    if (Array.isArray(val))
+                        return dump_list(val);
+                    if (ArrayBuffer.isView(val))
+                        return dump_buffer(val);
+                    return dump_object(val);
                 }
-                $mol_fail(new Error(`Unsupported type`));
             };
-            for (const item of data) {
+            const dump = (val) => {
+                const dumper = dumpers[typeof val];
+                if (!dumper)
+                    $mol_fail(new Error(`Unsupported type`));
+                dumper(val);
+            };
+            for (let i = 0; i < data.length; ++i) {
                 capacity += 9;
-                dump(item);
+                dump(data[i]);
                 if (stack.length)
-                    $mol_fail(new Error('Stack underflow', { cause: { stack, item } }));
+                    $mol_fail(new Error('Stack underflow', { cause: { stack, item: data[i] } }));
                 offsets.clear();
             }
             if (pos !== capacity)
@@ -2832,12 +2853,12 @@ var $;
         }
         rich_node(keys) {
             let node = this.rich_index;
-            for (const key of keys) {
-                let sub = node.get(key);
+            for (let i = 0; i < keys.length; ++i) {
+                let sub = node.get(keys[i]);
                 if (sub)
                     node = sub;
                 else
-                    node.set(key, node = new Map);
+                    node.set(keys[i], node = new Map);
             }
             return node;
         }