mol_vary 0.0.1

package/node.mjs

@@ -0,0 +1,771 @@
+#!/usr/bin/env node
+"use strict";
+var exports = void 0;
+
+var $node = $node || {}
+void function( module ) { var exports = module.exports = this; function require( id ) { return $node[ id.replace( /^.\// , "../" ) ] }; 
+;
+"use strict";
+Error.stackTraceLimit = 50;
+var $;
+(function ($) {
+})($ || ($ = {}));
+module.exports = $;
+
+;
+
+$node[ "../mam.ts" ] = $node[ "../mam.ts" ] = module.exports }.call( {} , {} )
+;
+"use strict"
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if ((d = decorators[i])) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+var $ = ( typeof module === 'object' ) ? ( module['export'+'s'] = globalThis ) : globalThis
+$.$$ = $
+
+;
+"use strict";
+var $;
+(function ($) {
+    function $mol_fail(error) {
+        throw error;
+    }
+    $.$mol_fail = $mol_fail;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    function $mol_hash_numbers(buff, seed = 0) {
+        let h1 = 0xdeadbeef ^ seed;
+        let h2 = 0x41c6ce57 ^ seed;
+        for (let i = 0; i < buff.length; ++i) {
+            const item = buff[i];
+            h1 = Math.imul(h1 ^ item, 2654435761);
+            h2 = Math.imul(h2 ^ item, 1597334677);
+        }
+        h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+        h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+        return 4294967296 * (((1 << 16) - 1) & h2) + (h1 >>> 0);
+    }
+    $.$mol_hash_numbers = $mol_hash_numbers;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    function $mol_bigint_encode(num) {
+        const minus = num < 0n ? 255 : 0;
+        num = minus ? -num - 1n : num;
+        const bytes = [];
+        do {
+            let byte = minus ^ Number(num % 256n);
+            bytes.push(byte);
+            if (num >>= 8n)
+                continue;
+            if ((minus & 128) !== (byte & 128))
+                bytes.push(minus);
+            break;
+        } while (num);
+        return new Uint8Array(bytes);
+    }
+    $.$mol_bigint_encode = $mol_bigint_encode;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    function $mol_hash_string(str, seed = 0) {
+        return $mol_hash_numbers([...str].map(ch => ch.codePointAt(0)));
+    }
+    $.$mol_hash_string = $mol_hash_string;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    let buf = new Uint8Array(2 ** 12);
+    function $mol_charset_encode(str) {
+        const capacity = str.length * 3;
+        if (buf.byteLength < capacity)
+            buf = new Uint8Array(capacity);
+        return buf.slice(0, $mol_charset_encode_to(str, buf));
+    }
+    $.$mol_charset_encode = $mol_charset_encode;
+    function $mol_charset_encode_to(str, buf, from = 0) {
+        let pos = from;
+        for (let i = 0; i < str.length; i++) {
+            let code = str.charCodeAt(i);
+            if (code < 0x80) {
+                buf[pos++] = code;
+            }
+            else if (code < 0x800) {
+                buf[pos++] = 0xc0 | (code >> 6);
+                buf[pos++] = 0x80 | (code & 0x3f);
+            }
+            else if (code < 0xd800 || code >= 0xe000) {
+                buf[pos++] = 0xe0 | (code >> 12);
+                buf[pos++] = 0x80 | ((code >> 6) & 0x3f);
+                buf[pos++] = 0x80 | (code & 0x3f);
+            }
+            else {
+                const point = ((code - 0xd800) << 10) + str.charCodeAt(++i) + 0x2400;
+                buf[pos++] = 0xf0 | (point >> 18);
+                buf[pos++] = 0x80 | ((point >> 12) & 0x3f);
+                buf[pos++] = 0x80 | ((point >> 6) & 0x3f);
+                buf[pos++] = 0x80 | (point & 0x3f);
+            }
+        }
+        return pos - from;
+    }
+    $.$mol_charset_encode_to = $mol_charset_encode_to;
+    function $mol_charset_encode_size(str) {
+        let size = 0;
+        for (let i = 0; i < str.length; i++) {
+            let code = str.charCodeAt(i);
+            if (code < 0x80)
+                size += 1;
+            else if (code < 0x800)
+                size += 2;
+            else if (code < 0xd800 || code >= 0xe000)
+                size += 3;
+            else
+                size += 4;
+        }
+        return size;
+    }
+    $.$mol_charset_encode_size = $mol_charset_encode_size;
+})($ || ($ = {}));
+
+;
+"use strict";
+
+;
+"use strict";
+var $;
+(function ($) {
+    const decoders = {};
+    function $mol_charset_decode(buffer, encoding = 'utf8') {
+        let decoder = decoders[encoding];
+        if (!decoder)
+            decoder = decoders[encoding] = new TextDecoder(encoding);
+        return decoder.decode(buffer);
+    }
+    $.$mol_charset_decode = $mol_charset_decode;
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    let $mol_vary_tip;
+    (function ($mol_vary_tip) {
+        $mol_vary_tip[$mol_vary_tip["uint"] = 0] = "uint";
+        $mol_vary_tip[$mol_vary_tip["link"] = 32] = "link";
+        $mol_vary_tip[$mol_vary_tip["spec"] = 64] = "spec";
+        $mol_vary_tip[$mol_vary_tip["list"] = 96] = "list";
+        $mol_vary_tip[$mol_vary_tip["text"] = 128] = "text";
+        $mol_vary_tip[$mol_vary_tip["blob"] = 160] = "blob";
+        $mol_vary_tip[$mol_vary_tip["tupl"] = 192] = "tupl";
+        $mol_vary_tip[$mol_vary_tip["sint"] = 224] = "sint";
+    })($mol_vary_tip = $.$mol_vary_tip || ($.$mol_vary_tip = {}));
+    $.$mol_vary_len = {
+        1: 28,
+        2: 29,
+        4: 30,
+        8: 31,
+    };
+    let $mol_vary_spec;
+    (function ($mol_vary_spec) {
+        $mol_vary_spec[$mol_vary_spec["none"] = 'N'.charCodeAt(0)] = "none";
+        $mol_vary_spec[$mol_vary_spec["true"] = 'T'.charCodeAt(0)] = "true";
+        $mol_vary_spec[$mol_vary_spec["fake"] = 'F'.charCodeAt(0)] = "fake";
+        $mol_vary_spec[$mol_vary_spec["both"] = 'B'.charCodeAt(0)] = "both";
+        $mol_vary_spec[$mol_vary_spec["fp16"] = 93] = "fp16";
+        $mol_vary_spec[$mol_vary_spec["fp32"] = 94] = "fp32";
+        $mol_vary_spec[$mol_vary_spec["fp64"] = 95] = "fp64";
+    })($mol_vary_spec = $.$mol_vary_spec || ($.$mol_vary_spec = {}));
+    function num_len(num) {
+        if (typeof num === 'number' && !Number.isInteger(num))
+            return 8;
+        if (num < 0) {
+            if (num >= -28)
+                return 0;
+            if (num >= -(2 ** 7))
+                return 1;
+            if (num >= -(2 ** 15))
+                return 2;
+            if (num >= -(2 ** 31))
+                return 4;
+            if (num >= -(2n ** 63n))
+                return 8;
+            $mol_fail(new Error(`Too low numb ${num}`));
+        }
+        else {
+            if (num < 28)
+                return 0;
+            if (num < 2 ** 8)
+                return 1;
+            if (num < 2 ** 16)
+                return 2;
+            if (num < 2 ** 32)
+                return 4;
+            if (num < 2n ** 64n)
+                return 8;
+            $mol_fail(new Error(`Too high numb ${num}`));
+        }
+    }
+    class $mol_vary extends DataView {
+        static pack(data) {
+            const leaned = new WeakMap();
+            const lean = (val) => {
+                let tupl = leaned.get(val);
+                if (tupl)
+                    return tupl;
+                leaned.set(val, tupl = this.lean(val));
+                return tupl;
+            };
+            const hashes = new Map();
+            const hash = (val) => {
+                switch (typeof val) {
+                    case 'undefined':
+                        return 0;
+                    case 'number':
+                    case 'boolean':
+                        return Number(val);
+                    case 'number':
+                        return val;
+                    case 'bigint':
+                        return $mol_hash_numbers($mol_bigint_encode(val), $mol_vary_tip.sint);
+                    case 'string': {
+                        let res = hashes.get(val);
+                        if (res != null)
+                            return res;
+                        res = $mol_hash_string(val, $mol_vary_tip.text);
+                        hashes.set(val, res);
+                        return res;
+                    }
+                    case 'object': {
+                        if (!val)
+                            return $mol_vary_spec.none;
+                        let res = hashes.get(val);
+                        if (res != null)
+                            return res;
+                        if (ArrayBuffer.isView(val))
+                            res = $mol_hash_numbers(new Uint8Array(val.buffer, val.byteOffset, val.byteLength), $mol_vary_tip.blob);
+                        else if (Array.isArray(val))
+                            res = $mol_hash_numbers(val.map(hash), $mol_vary_tip.list);
+                        else {
+                            const [keys, vals] = lean(val);
+                            res = $mol_hash_numbers([hash(keys), ...vals.map(hash)], $mol_vary_tip.tupl);
+                        }
+                        hashes.set(val, res);
+                        return res;
+                    }
+                }
+                $mol_fail(new Error(`Unsupported type`));
+            };
+            let size = 0;
+            const offsets = new Map();
+            const sizes = new Map();
+            const stream = [];
+            const dedup = (val, len) => {
+                const key = hash(val);
+                let offset = offsets.get(key);
+                if (offset === undefined) {
+                    offsets.set(key, offset = stream.length);
+                    stream.push(val);
+                    size += len;
+                    return true;
+                }
+                else {
+                    size += 1 + num_len(offset);
+                    return false;
+                }
+            };
+            const calc = (val) => {
+                if (val == null) {
+                    size += 1;
+                    return true;
+                }
+                switch (typeof val) {
+                    case 'boolean':
+                        size += 1;
+                        return true;
+                    case 'number':
+                    case 'bigint':
+                        size += 1 + num_len(val);
+                        return true;
+                    case 'string': {
+                        let len = sizes.get(val);
+                        if (len == null)
+                            sizes.set(val, len = $mol_charset_encode_size(val));
+                        if (!len) {
+                            size += 1;
+                            return true;
+                        }
+                        return dedup(val, 1 + num_len(len) + len);
+                    }
+                    case 'object': {
+                        if (ArrayBuffer.isView(val)) {
+                            if (!val.byteLength) {
+                                size += 2;
+                                return true;
+                            }
+                            return dedup(val, 2 + num_len(val.byteLength) + val.byteLength);
+                        }
+                        if (Array.isArray(val)) {
+                            if (!val.length) {
+                                size += 1;
+                                return true;
+                            }
+                            const key = hash(val);
+                            let offset = offsets.get(key);
+                            if (offset === undefined) {
+                                for (const item of val)
+                                    calc(item);
+                            }
+                            return dedup(val, 1 + num_len(val.length));
+                        }
+                        const [keys, vals] = lean(val);
+                        if (!vals.length) {
+                            size += 2;
+                            return true;
+                        }
+                        const key = hash(val);
+                        let offset = offsets.get(key);
+                        if (offset === undefined) {
+                            calc(keys);
+                            for (const item of vals)
+                                calc(item);
+                        }
+                        return dedup(val, 1 + num_len(vals.length));
+                    }
+                }
+                $mol_fail(new Error(`Unsupported type`));
+            };
+            calc(data);
+            const buf = new Uint8Array(size);
+            const pack = new this(buf.buffer);
+            const embedded = new Set();
+            let pos = 0;
+            const dump = (val) => {
+                if (pos >= size)
+                    $mol_fail(new Error('Wrong buffer length', { cause: buf }));
+                switch (typeof val) {
+                    case 'undefined': {
+                        pack.tlen(pos, 'spec', $mol_vary_spec.both);
+                        pos += 1;
+                        return;
+                    }
+                    case 'boolean': {
+                        pack.tlen(pos, 'spec', val ? $mol_vary_spec.true : $mol_vary_spec.fake);
+                        pos += 1;
+                        return;
+                    }
+                    case 'number': {
+                        if (!Number.isInteger(val)) {
+                            pos += pack.tfp(pos, 'spec', val);
+                        }
+                        else if (val < 0) {
+                            pos += pack.tint(pos, 'sint', val);
+                        }
+                        else {
+                            pos += pack.tnat(pos, 'uint', val);
+                        }
+                        return;
+                    }
+                    case 'bigint': {
+                        if (val < 0) {
+                            pos += pack.tint(pos, 'sint', val);
+                        }
+                        else {
+                            pos += pack.tnat(pos, 'uint', val);
+                        }
+                        return;
+                    }
+                    case 'string': {
+                        const key = hash(val);
+                        if (embedded.has(key)) {
+                            pos += pack.tnat(pos, 'link', offsets.get(key));
+                            return;
+                        }
+                        pos += pack.tnat(pos, 'text', sizes.get(val));
+                        pos += $mol_charset_encode_to(val, buf, pos);
+                        if (val.length)
+                            embedded.add(key);
+                        return;
+                    }
+                    case 'object': {
+                        if (!val) {
+                            pack.tlen(pos, 'spec', $mol_vary_spec.none);
+                            pos += 1;
+                            return;
+                        }
+                        if (ArrayBuffer.isView(val)) {
+                            const key = hash(val);
+                            if (embedded.has(key)) {
+                                pos += pack.tnat(pos, 'link', offsets.get(key));
+                                return;
+                            }
+                            pos += pack.tnat(pos, 'blob', val.byteLength);
+                            if (val instanceof Uint8Array)
+                                pos += pack.tlen(pos, 'uint', $.$mol_vary_len[1]);
+                            else if (val instanceof Uint16Array)
+                                pos += pack.tlen(pos, 'uint', $.$mol_vary_len[2]);
+                            else if (val instanceof Uint32Array)
+                                pos += pack.tlen(pos, 'uint', $.$mol_vary_len[4]);
+                            else if (val instanceof BigUint64Array)
+                                pos += pack.tlen(pos, 'uint', $.$mol_vary_len[8]);
+                            else if (val instanceof Int8Array)
+                                pos += pack.tlen(pos, 'sint', ~$.$mol_vary_len[1]);
+                            else if (val instanceof Int16Array)
+                                pos += pack.tlen(pos, 'sint', ~$.$mol_vary_len[2]);
+                            else if (val instanceof Int32Array)
+                                pos += pack.tlen(pos, 'sint', ~$.$mol_vary_len[4]);
+                            else if (val instanceof BigInt64Array)
+                                pos += pack.tlen(pos, 'sint', ~$.$mol_vary_len[8]);
+                            else if (val instanceof Float32Array)
+                                pos += pack.tlen(pos, 'spec', $mol_vary_spec.fp32);
+                            else if (val instanceof Float64Array)
+                                pos += pack.tlen(pos, 'spec', $mol_vary_spec.fp64);
+                            else
+                                $mol_fail(new Error(`Unsupported type`));
+                            buf.set(new Uint8Array(val.buffer, val.byteOffset, val.byteLength), pos);
+                            pos += val.byteLength;
+                            if (val.byteLength)
+                                embedded.add(key);
+                            return;
+                        }
+                        if (Array.isArray(val)) {
+                            const key = hash(val);
+                            if (embedded.has(key)) {
+                                pos += pack.tnat(pos, 'link', offsets.get(key));
+                                return;
+                            }
+                            pos += pack.tnat(pos, 'list', val.length);
+                            for (const item of val)
+                                dump(item);
+                            if (val.length)
+                                embedded.add(key);
+                            return;
+                        }
+                        const key = hash(val);
+                        if (embedded.has(key)) {
+                            pos += pack.tnat(pos, 'link', offsets.get(key));
+                            return;
+                        }
+                        const [keys, vals] = lean(val);
+                        pos += pack.tnat(pos, 'tupl', vals.length);
+                        dump(keys);
+                        for (const item of vals)
+                            dump(item);
+                        if (vals.length)
+                            embedded.add(key);
+                        return;
+                    }
+                }
+                $mol_fail(new Error(`Unsupported type`));
+            };
+            dump(data);
+            return buf;
+        }
+        static take(buf) {
+            const pack = new $mol_vary(buf.buffer, buf.byteOffset, buf.byteLength);
+            const stream = [];
+            let pos = 0;
+            const read_unum = () => {
+                const num = pack.unum(pos);
+                pos += 1 + pack.ulen(pos);
+                return num;
+            };
+            const read_snum = () => {
+                const num = pack.snum(pos);
+                pos += 1 + pack.slen(pos);
+                return num;
+            };
+            const read_text = () => {
+                const len = read_unum();
+                const bin = new Uint8Array(buf.buffer, pack.byteOffset + pos, len);
+                pos += len;
+                const text = $mol_charset_decode(bin);
+                if (text.length)
+                    stream.push(text);
+                return text;
+            };
+            const read_buffer = (len, TypedArray) => {
+                const bin = new TypedArray(buf.slice(pos, pos + len).buffer);
+                pos += len;
+                if (len)
+                    stream.push(bin);
+                return bin;
+            };
+            const read_blob = () => {
+                const len = read_unum();
+                const kind = pack.getUint8(pos++);
+                switch (kind) {
+                    case $mol_vary_tip.uint | $.$mol_vary_len[1]: return read_buffer(len, Uint8Array);
+                    case $mol_vary_tip.uint | $.$mol_vary_len[2]: return read_buffer(len, Uint16Array);
+                    case $mol_vary_tip.uint | $.$mol_vary_len[4]: return read_buffer(len, Uint32Array);
+                    case $mol_vary_tip.uint | $.$mol_vary_len[8]: return read_buffer(len, BigUint64Array);
+                    case $mol_vary_tip.sint | ~$.$mol_vary_len[1] + 256: return read_buffer(len, Int8Array);
+                    case $mol_vary_tip.sint | ~$.$mol_vary_len[2] + 256: return read_buffer(len, Int16Array);
+                    case $mol_vary_tip.sint | ~$.$mol_vary_len[4] + 256: return read_buffer(len, Int32Array);
+                    case $mol_vary_tip.sint | ~$.$mol_vary_len[8] + 256: return read_buffer(len, BigInt64Array);
+                    case $mol_vary_tip.spec | $mol_vary_spec.fp32: return read_buffer(len, Float32Array);
+                    case $mol_vary_tip.spec | $mol_vary_spec.fp64: return read_buffer(len, Float64Array);
+                    default:
+                        $mol_fail(new Error('Unsupported blob kind', { cause: { kind } }));
+                }
+            };
+            const read_list = () => {
+                const len = read_unum();
+                const list = [];
+                for (let i = 0; i < len; ++i)
+                    list.push(read_vary());
+                if (len)
+                    stream.push(list);
+                return list;
+            };
+            const read_link = () => {
+                const index = read_unum();
+                if (index >= stream.length)
+                    $mol_fail(new Error('Too large index', { cause: { index, exists: stream.length } }));
+                return stream[index];
+            };
+            const read_tupl = () => {
+                const len = read_unum();
+                const keys = pack.tip(pos) === 'link' ? read_link() : read_list();
+                if (!Array.isArray(keys))
+                    $mol_fail(new Error('Wrong tupl shape type', { cause: { type: typeof keys } }));
+                const vals = Array.from({ length: len }, () => read_vary());
+                const obj = this.rich(keys, vals);
+                if (vals.length)
+                    stream.push(obj);
+                return obj;
+            };
+            const read_spec = () => {
+                const kind = pack.getUint8(pos);
+                const spec = $mol_vary_spec[kind];
+                switch (spec) {
+                    case 'none':
+                        ++pos;
+                        return null;
+                    case 'fake':
+                        ++pos;
+                        return false;
+                    case 'true':
+                        ++pos;
+                        return true;
+                    case 'both':
+                        ++pos;
+                        return undefined;
+                    case 'fp16': {
+                        const val = pack.getFloat16(pos + 1, true);
+                        pos += 3;
+                        return val;
+                    }
+                    case 'fp32': {
+                        const val = pack.getFloat32(pos + 1, true);
+                        pos += 5;
+                        return val;
+                    }
+                    case 'fp64': {
+                        const val = pack.getFloat64(pos + 1, true);
+                        pos += 9;
+                        return val;
+                    }
+                    default:
+                        $mol_fail(new Error('Unsupported spec', { cause: { kind } }));
+                }
+            };
+            const read_vary = () => {
+                const tip = pack.tip(pos);
+                switch (tip) {
+                    case 'uint': return read_unum();
+                    case 'sint': return read_snum();
+                    case 'link': return read_link();
+                    case 'text': return read_text();
+                    case 'list': return read_list();
+                    case 'blob': return read_blob();
+                    case 'tupl': return read_tupl();
+                    case 'spec': return read_spec();
+                    default: $mol_fail(new Error('Unsupported tip', { cause: { tip } }));
+                }
+            };
+            return read_vary();
+        }
+        tlen(pos, tip, len) {
+            this.setUint8(pos, $mol_vary_tip[tip] | len);
+            return 1;
+        }
+        tnat(pos, tip, num) {
+            const len = num_len(num);
+            this.tlen(pos, tip, len ? $.$mol_vary_len[len] : Number(num));
+            switch (len) {
+                case 0: break;
+                case 1:
+                    this.setUint8(pos + 1, Number(num));
+                    break;
+                case 2:
+                    this.setUint16(pos + 1, Number(num), true);
+                    break;
+                case 4:
+                    this.setUint32(pos + 1, Number(num), true);
+                    break;
+                case 8:
+                    this.setBigUint64(pos + 1, BigInt(num), true);
+                    break;
+                default: $mol_fail(new Error('Unsupported uint len', { cause: { len } }));
+            }
+            return 1 + len;
+        }
+        tint(pos, tip, num) {
+            const len = num_len(num);
+            this.tlen(pos, tip, len ? -$.$mol_vary_len[len] - 1 : Number(num));
+            switch (len) {
+                case 0: break;
+                case 1:
+                    this.setInt8(pos + 1, Number(num));
+                    break;
+                case 2:
+                    this.setInt16(pos + 1, Number(num), true);
+                    break;
+                case 4:
+                    this.setInt32(pos + 1, Number(num), true);
+                    break;
+                case 8:
+                    this.setBigInt64(pos + 1, BigInt(num), true);
+                    break;
+                default: $mol_fail(new Error('Unsupported sint len', { cause: { len } }));
+            }
+            return 1 + len;
+        }
+        tfp(pos, tip, num) {
+            const len = num_len(num);
+            this.tlen(pos, tip, len ? $.$mol_vary_len[len] : Number(num));
+            switch (len) {
+                case 2:
+                    this.setFloat16(pos + 1, num, true);
+                    break;
+                case 4:
+                    this.setFloat32(pos + 1, num, true);
+                    break;
+                case 8:
+                    this.setFloat64(pos + 1, num, true);
+                    break;
+                default: $mol_fail(new Error('Unsupported fp len', { cause: { len } }));
+            }
+            return 1 + len;
+        }
+        tip(pos) {
+            return $mol_vary_tip[this.getUint8(pos) & 0b111_00000];
+        }
+        ulen(pos) {
+            const num = this.getUint8(pos) & 0b11111;
+            if (num < 28)
+                return 0;
+            switch (num) {
+                case 28: return 1;
+                case 29: return 2;
+                case 30: return 4;
+                case 31: return 8;
+                default: $mol_fail(new Error('Impossible!'));
+            }
+        }
+        slen(pos) {
+            const num = this.getInt8(pos);
+            if (num > -29)
+                return 0;
+            switch (num) {
+                case -29: return 1;
+                case -30: return 2;
+                case -31: return 4;
+                case -32: return 8;
+                default: $mol_fail(new Error('Impossible!'));
+            }
+        }
+        unum(pos) {
+            const num = this.getUint8(pos) & 0b11111;
+            if (num < 28)
+                return num;
+            switch (num) {
+                case 28: return this.getUint8(pos + 1);
+                case 29: return this.getUint16(pos + 1, true);
+                case 30: return this.getUint32(pos + 1, true);
+                case 31:
+                    const val = this.getBigUint64(pos + 1, true);
+                    if (val > Number.MAX_SAFE_INTEGER)
+                        return val;
+                    return Number(val);
+                default: $mol_fail(new Error('Unsupported len', { cause: { num } }));
+            }
+        }
+        snum(pos) {
+            const num = this.getInt8(pos);
+            if (num > -29)
+                return num;
+            switch (num) {
+                case -29: return this.getInt8(pos + 1);
+                case -30: return this.getInt16(pos + 1, true);
+                case -31: return this.getInt32(pos + 1, true);
+                case -32:
+                    const val = this.getBigInt64(pos + 1, true);
+                    if (val > Number.MAX_SAFE_INTEGER)
+                        return val;
+                    if (val < Number.MIN_SAFE_INTEGER)
+                        return val;
+                    return Number(val);
+                default: $mol_fail(new Error('Unsupported len', { cause: { num } }));
+            }
+        }
+        static rich(keys, vals) {
+            const shape = JSON.stringify([keys, vals.map(v => typeof v)]);
+            const rich = this.riches.get(shape);
+            if (rich)
+                return rich(...vals);
+            const pairs = keys.map((key, index) => [key, vals[index]]);
+            const obj = Object.fromEntries(pairs);
+            return obj;
+        }
+        static lean(val) {
+            const proto = Reflect.getPrototypeOf(val);
+            const lean = this.leanes.get(proto);
+            if (lean)
+                return lean(val);
+            return [Object.keys(val), Object.values(val)];
+        }
+        static leanes = new Map();
+        static riches = new Map();
+        static register(rich, lean) {
+            const obj = rich();
+            const proto = Reflect.getPrototypeOf(obj);
+            const [keys, vals] = lean(obj);
+            const shape = JSON.stringify([keys, vals.map(v => typeof v)]);
+            this.leanes.set(proto, lean);
+            this.riches.set(shape, rich);
+        }
+    }
+    $.$mol_vary = $mol_vary;
+    $mol_vary.register((keys = [], vals = []) => new Map(keys.map((k, i) => [k, vals[i]])), obj => [
+        ['keys', 'vals'],
+        [[...obj.keys()], [...obj.values()]],
+    ]);
+    $mol_vary.register((vals = []) => new Set(vals), obj => [
+        ['vals'],
+        [[...obj.values()]],
+    ]);
+})($ || ($ = {}));
+
+
+export default $
+//# sourceMappingURL=node.js.map