mol_vary 0.0.5 → 0.0.7

package/node.test.js

@@ -29,60 +29,6 @@ var $;
     $.$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) {
-        let nums = new Array(str.length);
-        for (let i = 0; i < str.length; ++i)
-            nums[i] = str.charCodeAt(i);
-        return $mol_hash_numbers(nums);
-    }
-    $.$mol_hash_string = $mol_hash_string;
-})($ || ($ = {}));
-
 ;
 "use strict";
 var $;
@@ -157,6 +103,59 @@ var $;
     $.$mol_charset_decode = $mol_charset_decode;
 })($ || ($ = {}));
 
+;
+"use strict";
+var $;
+(function ($) {
+    function $mol_charset_decode_from(buffer, from, count) {
+        let res = '';
+        let pos = from;
+        while (pos < buffer.length && res.length < count) {
+            const byte1 = buffer[pos++];
+            if (byte1 <= 0x7F) {
+                res += String.fromCharCode(byte1);
+            }
+            else if ((byte1 & 0xE0) === 0xC0) {
+                if (pos >= buffer.length)
+                    break;
+                const byte2 = buffer[pos++];
+                let code = ((byte1 & 0x1F) << 6) | (byte2 & 0x3F);
+                res += String.fromCharCode(code);
+            }
+            else if ((byte1 & 0xF0) === 0xE0) {
+                if (pos + 1 >= buffer.length)
+                    break;
+                const byte2 = buffer[pos++];
+                const byte3 = buffer[pos++];
+                let code = ((byte1 & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F);
+                res += String.fromCharCode(code);
+            }
+            else if ((byte1 & 0xF8) === 0xF0) {
+                if (pos + 2 >= buffer.length)
+                    break;
+                const byte2 = buffer[pos++];
+                const byte3 = buffer[pos++];
+                const byte4 = buffer[pos++];
+                let code = ((byte1 & 0x07) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F);
+                if (code > 0xFFFF) {
+                    code -= 0x10000;
+                    const hi = 0xD800 + (code >> 10);
+                    const lo = 0xDC00 + (code & 0x3FF);
+                    res += String.fromCharCode(hi, lo);
+                }
+                else {
+                    res += String.fromCharCode(code);
+                }
+            }
+            else {
+                res += '�';
+            }
+        }
+        return [res, pos - from];
+    }
+    $.$mol_charset_decode_from = $mol_charset_decode_from;
+})($ || ($ = {}));
+
 ;
 "use strict";
 var $;
@@ -188,319 +187,286 @@ var $;
         $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}`));
-        }
-    }
+    let offsets = new Map();
+    let sizes = new Map();
     class $mol_vary extends DataView {
-        static buffer = new Uint8Array(4096);
-        static buffer_view = new this(this.buffer.buffer);
-        static allocate(size) {
-            if (this.buffer.byteLength > size)
-                return;
-            this.buffer = new Uint8Array(Math.ceil(size / 4096) * 4096);
-            this.buffer_view = new this(this.buffer.buffer);
-        }
         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;
+            let pos = 0;
+            let capacity = 0;
+            const acquire = (size) => {
+                capacity += size;
+                if (buffer.byteLength >= capacity)
+                    return;
+                const buffer2 = new Uint8Array(Math.ceil(capacity / 4096) * 4096);
+                buffer2.set(buffer);
+                buffer = buffer2;
+                pack = new DataView(buffer.buffer);
             };
-            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(vals.map(hash), hash(keys));
-                        }
-                        hashes.set(val, res);
-                        return res;
-                    }
+            const release = (size) => {
+                capacity -= size;
+            };
+            const dump_snum = (tip, val) => {
+                if (val >= -28) {
+                    pack.setInt8(pos++, tip | Number(val));
+                    release(9);
+                }
+                else if (val >= -(2 ** 7)) {
+                    pack.setInt8(pos++, tip | (-1 - $.$mol_vary_len[1]));
+                    pack.setInt8(pos, Number(val));
+                    pos += 1;
+                    release(8);
+                }
+                else if (val >= -(2 ** 15)) {
+                    pack.setInt8(pos++, tip | (-1 - $.$mol_vary_len[2]));
+                    pack.setInt16(pos, Number(val), true);
+                    pos += 2;
+                    release(7);
+                }
+                else if (val >= -(2 ** 31)) {
+                    pack.setInt8(pos++, tip | (-1 - $.$mol_vary_len[4]));
+                    pack.setInt32(pos, Number(val), true);
+                    pos += 4;
+                    release(5);
+                }
+                else if (val >= -(2n ** 63n)) {
+                    pack.setInt8(pos++, tip | (-1 - $.$mol_vary_len[8]));
+                    pack.setBigInt64(pos, BigInt(val), true);
+                    pos += 8;
+                    release(1);
+                }
+                else {
+                    $mol_fail(new Error('Number too low', { cause: val }));
                 }
-                $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;
+            const dump_unum = (tip, val) => {
+                if (val < 28) {
+                    pack.setUint8(pos++, tip | Number(val));
+                    release(9);
+                }
+                else if (val < 2 ** 8) {
+                    pack.setUint8(pos++, tip | $.$mol_vary_len[1]);
+                    pack.setUint8(pos, Number(val));
+                    pos += 1;
+                    release(8);
+                }
+                else if (val < 2 ** 16) {
+                    pack.setUint8(pos++, tip | $.$mol_vary_len[2]);
+                    pack.setUint16(pos, Number(val), true);
+                    pos += 2;
+                    release(7);
+                }
+                else if (val < 2 ** 32) {
+                    pack.setUint8(pos++, tip | $.$mol_vary_len[4]);
+                    pack.setUint32(pos, Number(val), true);
+                    pos += 4;
+                    release(5);
+                }
+                else if (val < 2n ** 64n) {
+                    pack.setUint8(pos++, tip | $.$mol_vary_len[8]);
+                    pack.setBigUint64(pos, BigInt(val), true);
+                    pos += 8;
+                    release(1);
                 }
                 else {
-                    size += 1 + num_len(offset);
-                    return false;
+                    $mol_fail(new Error('Number too high', { cause: val }));
                 }
             };
-            const calc = (val) => {
-                if (val == null) {
-                    size += 1;
-                    return true;
+            const dump_string = (val) => {
+                if (val.length) {
+                    const offset = offsets.get(val);
+                    if (offset !== undefined)
+                        return dump_unum($mol_vary_tip.link, offset);
                 }
-                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));
-                    }
+                dump_unum($mol_vary_tip.text, val.length);
+                acquire(val.length * 3);
+                const len = $mol_charset_encode_to(val, buffer, pos);
+                pos += len;
+                release(val.length * 3 - len - 1);
+                if (val.length)
+                    offsets.set(val, offsets.size);
+                return;
+            };
+            const dump_buffer = (val) => {
+                if (val.byteLength) {
+                    const offset = offsets.get(val);
+                    if (offset !== undefined)
+                        return dump_unum($mol_vary_tip.link, offset);
                 }
-                $mol_fail(new Error(`Unsupported type`));
+                dump_unum($mol_vary_tip.blob, val.byteLength);
+                if (val instanceof Uint8Array)
+                    pack.setUint8(pos++, $mol_vary_tip.uint | $.$mol_vary_len[1]);
+                else if (val instanceof Uint16Array)
+                    pack.setUint8(pos++, $mol_vary_tip.uint | $.$mol_vary_len[2]);
+                else if (val instanceof Uint32Array)
+                    pack.setUint8(pos++, $mol_vary_tip.uint | $.$mol_vary_len[4]);
+                else if (val instanceof BigUint64Array)
+                    pack.setUint8(pos++, $mol_vary_tip.uint | $.$mol_vary_len[8]);
+                else if (val instanceof Int8Array)
+                    pack.setUint8(pos++, $mol_vary_tip.sint | ~$.$mol_vary_len[1]);
+                else if (val instanceof Int16Array)
+                    pack.setUint8(pos++, $mol_vary_tip.sint | ~$.$mol_vary_len[2]);
+                else if (val instanceof Int32Array)
+                    pack.setUint8(pos++, $mol_vary_tip.sint | ~$.$mol_vary_len[4]);
+                else if (val instanceof BigInt64Array)
+                    pack.setUint8(pos++, $mol_vary_tip.sint | ~$.$mol_vary_len[8]);
+                else if (val instanceof Float32Array)
+                    pack.setUint8(pos++, $mol_vary_spec.fp32);
+                else if (val instanceof Float64Array)
+                    pack.setUint8(pos++, $mol_vary_spec.fp64);
+                else
+                    $mol_fail(new Error(`Unsupported type`));
+                const src = (val instanceof Uint8Array) ? val : new Uint8Array(val.buffer, val.byteOffset, val.byteLength);
+                acquire(val.byteLength);
+                buffer.set(src, pos);
+                pos += val.byteLength;
+                if (val.byteLength)
+                    offsets.set(val, offsets.size);
+            };
+            const dump_list = (val) => {
+                if (val.length) {
+                    const offset = offsets.get(val);
+                    if (offset !== undefined)
+                        return dump_unum($mol_vary_tip.link, offset);
+                }
+                dump_unum($mol_vary_tip.list, val.length);
+                acquire(val.length * 10);
+                for (const item of val)
+                    dump(item);
+                if (val.length)
+                    offsets.set(val, offsets.size);
+            };
+            const dump_object = (val) => {
+                const offset = offsets.get(val);
+                if (offset !== undefined)
+                    return dump_unum($mol_vary_tip.link, offset);
+                const proto = Reflect.getPrototypeOf(val);
+                const lean = this.leanes.get(proto);
+                const keys = lean ? this.keys.get(proto) : Object.keys(val);
+                const vals = lean ? lean(val) : Object.values(val);
+                dump_unum($mol_vary_tip.tupl, vals.length);
+                acquire(vals.length * 2 * 10);
+                for (const item of keys)
+                    dump(item);
+                for (const item of vals)
+                    dump(item);
+                if (vals.length)
+                    offsets.set(val, offsets.size);
             };
-            calc(data);
-            this.allocate(size);
-            const buf = this.buffer;
-            const pack = this.buffer_view;
-            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;
+                        pack.setUint8(pos++, $mol_vary_spec.both);
+                        release(9);
                         return;
                     }
                     case 'boolean': {
-                        pack.tlen(pos, 'spec', val ? $mol_vary_spec.true : $mol_vary_spec.fake);
-                        pos += 1;
+                        pack.setUint8(pos++, val ? $mol_vary_spec.true : $mol_vary_spec.fake);
+                        release(9);
                         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);
+                            pack.setUint8(pos++, $mol_vary_spec.fp64);
+                            pack.setFloat64(pos, val, true);
+                            pos += 8;
+                            release(1);
+                            return;
                         }
-                        return;
                     }
                     case 'bigint': {
                         if (val < 0) {
-                            pos += pack.tint(pos, 'sint', val);
+                            dump_snum($mol_vary_tip.sint, val);
                         }
                         else {
-                            pos += pack.tnat(pos, 'uint', val);
+                            dump_unum($mol_vary_tip.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 'string': return dump_string(val);
                     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;
+                            release(9);
+                            return pack.setUint8(pos++, $mol_vary_spec.none);
                         }
-                        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;
+                        if (ArrayBuffer.isView(val))
+                            return dump_buffer(val);
+                        if (Array.isArray(val))
+                            return dump_list(val);
+                        return dump_object(val);
                     }
                 }
                 $mol_fail(new Error(`Unsupported type`));
             };
             dump(data);
-            return buf.slice(0, size);
+            offsets = new Map;
+            sizes = new Map;
+            return buffer.slice(0, pos);
         }
         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_unum = (kind) => {
+                ++pos;
+                const num = kind & 0b11111;
+                if (num < 28)
+                    return num;
+                let res = 0;
+                if (num === 28) {
+                    res = pack.getUint8(pos);
+                    pos += 1;
+                }
+                else if (num === 29) {
+                    res = pack.getUint16(pos, true);
+                    pos += 2;
+                }
+                else if (num === 30) {
+                    res = pack.getUint32(pos, true);
+                    pos += 4;
+                }
+                else if (num === 31) {
+                    res = pack.getBigUint64(pos, true);
+                    if (res <= Number.MAX_SAFE_INTEGER)
+                        res = Number(res);
+                    pos += 8;
+                }
+                else {
+                    $mol_fail(new Error('Unsupported unum', { cause: { num } }));
+                }
+                return res;
             };
-            const read_snum = () => {
-                const num = pack.snum(pos);
-                pos += 1 + pack.slen(pos);
-                return num;
+            const read_snum = (kind) => {
+                const num = pack.getInt8(pos++);
+                if (num >= -28)
+                    return num;
+                let res = 0;
+                if (num === -29) {
+                    res = pack.getInt8(pos);
+                    pos += 1;
+                }
+                else if (num === -30) {
+                    res = pack.getInt16(pos, true);
+                    pos += 2;
+                }
+                else if (num === -31) {
+                    res = pack.getInt32(pos, true);
+                    pos += 4;
+                }
+                else if (num === -32) {
+                    res = pack.getBigInt64(pos, true);
+                    if (res >= Number.MIN_SAFE_INTEGER && res <= Number.MAX_SAFE_INTEGER)
+                        res = Number(res);
+                    pos += 8;
+                }
+                else {
+                    $mol_fail(new Error('Unsupported snum', { cause: { num } }));
+                }
+                return res;
             };
-            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);
+            const read_text = (kind) => {
+                const len = read_unum(kind);
+                const [text, bytes] = $mol_charset_decode_from(buf, pack.byteOffset + pos, len);
+                pos += bytes;
                 if (text.length)
                     stream.push(text);
                 return text;
@@ -512,79 +478,90 @@ var $;
                     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);
+            const read_blob = (kind) => {
+                const len = read_unum(kind);
+                const kind_item = pack.getUint8(pos++);
+                switch (kind_item) {
+                    case $.$mol_vary_len[1]: return read_buffer(len, Uint8Array);
+                    case $.$mol_vary_len[2]: return read_buffer(len, Uint16Array);
+                    case $.$mol_vary_len[4]: return read_buffer(len, Uint32Array);
+                    case $.$mol_vary_len[8]: return read_buffer(len, BigUint64Array);
+                    case ~$.$mol_vary_len[1] + 256: return read_buffer(len, Int8Array);
+                    case ~$.$mol_vary_len[2] + 256: return read_buffer(len, Int16Array);
+                    case ~$.$mol_vary_len[4] + 256: return read_buffer(len, Int32Array);
+                    case ~$.$mol_vary_len[8] + 256: return read_buffer(len, BigInt64Array);
+                    case $mol_vary_tip.spec | $mol_vary_spec.fp16: return read_buffer(len, Float16Array);
                     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 } }));
+                        $mol_fail(new Error('Unsupported blob item kind', { cause: { kind_item } }));
                 }
             };
-            const read_list = () => {
-                const len = read_unum();
-                const list = [];
+            const read_list = (kind) => {
+                const len = read_unum(kind);
+                const list = new Array(len);
                 for (let i = 0; i < len; ++i)
-                    list.push(read_vary());
+                    list[i] = read_vary();
                 if (len)
                     stream.push(list);
                 return list;
             };
-            const read_link = () => {
-                const index = read_unum();
+            const read_link = (kind) => {
+                const index = read_unum(kind);
                 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);
+            const read_tupl = (kind) => {
+                const len = read_unum(kind);
+                const keys = new Array(len);
+                const vals = new Array(len);
+                for (let i = 0; i < len; ++i)
+                    keys[i] = read_vary();
+                for (let i = 0; i < len; ++i)
+                    vals[i] = read_vary();
+                const shape = JSON.stringify([keys, vals.map(v => typeof v)]);
+                let obj;
+                const rich = this.riches.get(shape);
+                if (rich) {
+                    obj = rich(...vals);
+                }
+                else {
+                    obj = {};
+                    for (let i = 0; i < len; ++i)
+                        obj[keys[i]] = vals[i];
+                }
                 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':
+            const read_spec = (kind) => {
+                switch (kind) {
+                    case $mol_vary_spec.none:
                         ++pos;
                         return null;
-                    case 'fake':
+                    case $mol_vary_spec.fake:
                         ++pos;
                         return false;
-                    case 'true':
+                    case $mol_vary_spec.true:
                         ++pos;
                         return true;
-                    case 'both':
+                    case $mol_vary_spec.both:
                         ++pos;
                         return undefined;
-                    case 'fp16': {
-                        const val = pack.getFloat16(pos + 1, true);
-                        pos += 3;
+                    case $mol_vary_spec.fp64: {
+                        const val = pack.getFloat64(++pos, true);
+                        pos += 8;
                         return val;
                     }
-                    case 'fp32': {
-                        const val = pack.getFloat32(pos + 1, true);
-                        pos += 5;
+                    case $mol_vary_spec.fp32: {
+                        const val = pack.getFloat32(++pos, true);
+                        pos += 4;
                         return val;
                     }
-                    case 'fp64': {
-                        const val = pack.getFloat64(pos + 1, true);
-                        pos += 9;
+                    case $mol_vary_spec.fp16: {
+                        const val = pack.getFloat16(++pos, true);
+                        pos += 2;
                         return val;
                     }
                     default:
@@ -592,181 +569,41 @@ var $;
                 }
             };
             const read_vary = () => {
-                const tip = pack.tip(pos);
+                const kind = pack.getUint8(pos);
+                const tip = kind & 0b111_00000;
                 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();
+                    case $mol_vary_tip.uint: return read_unum(kind);
+                    case $mol_vary_tip.sint: return read_snum(kind);
+                    case $mol_vary_tip.link: return read_link(kind);
+                    case $mol_vary_tip.text: return read_text(kind);
+                    case $mol_vary_tip.list: return read_list(kind);
+                    case $mol_vary_tip.blob: return read_blob(kind);
+                    case $mol_vary_tip.tupl: return read_tupl(kind);
+                    case $mol_vary_tip.spec: return read_spec(kind);
                     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 keys = new Map();
         static riches = new Map();
-        static type(rich, lean) {
+        static type(keys, rich, lean) {
             const obj = rich();
             const proto = Reflect.getPrototypeOf(obj);
-            const [keys, vals] = lean(obj);
+            const vals = lean(obj);
             const shape = JSON.stringify([keys, vals.map(v => typeof v)]);
             this.leanes.set(proto, lean);
+            this.keys.set(proto, keys);
             this.riches.set(shape, rich);
         }
     }
     $.$mol_vary = $mol_vary;
-    $mol_vary.type((keys = [], vals = []) => new Map(keys.map((k, i) => [k, vals[i]])), obj => [
-        ['keys', 'vals'],
-        [[...obj.keys()], [...obj.values()]],
-    ]);
-    $mol_vary.type((vals = []) => new Set(vals), obj => [
-        ['vals'],
-        [[...obj.values()]],
-    ]);
+    let buffer = new Uint8Array(128);
+    let pack = new DataView(buffer.buffer);
+    $mol_vary.type(['keys', 'vals'], (keys = [], vals = []) => new Map(keys.map((k, i) => [k, vals[i]])), obj => [[...obj.keys()], [...obj.values()]]);
+    $mol_vary.type(['vals'], (vals = []) => new Set(vals), obj => [[...obj.values()]]);
+    $mol_vary.type(['unix_time'], (ts = 0) => new Date(ts * 1000), obj => [obj.valueOf() / 1000]);
 })($ || ($ = {}));
 
 ;
@@ -3973,156 +3810,6 @@ var $;
     });
 })($ || ($ = {}));
 
-;
-"use strict";
-var $;
-(function ($_1) {
-    var $$;
-    (function ($$) {
-        $mol_test({
-            "1 byte int"($) {
-                $mol_assert_equal($mol_bigint_encode(0n), new Uint8Array(new Int8Array([0]).buffer));
-                $mol_assert_equal($mol_bigint_encode(1n), new Uint8Array(new Int8Array([1]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-1n), new Uint8Array(new Int8Array([-1]).buffer));
-                $mol_assert_equal($mol_bigint_encode(127n), new Uint8Array(new Int8Array([127]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-128n), new Uint8Array(new Int8Array([-128]).buffer));
-            },
-            "2 byte int"($) {
-                $mol_assert_equal($mol_bigint_encode(128n), new Uint8Array(new Int16Array([128]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-129n), new Uint8Array(new Int16Array([-129]).buffer));
-                $mol_assert_equal($mol_bigint_encode(128n * 256n - 1n), new Uint8Array(new Int16Array([128 * 256 - 1]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-128n * 256n), new Uint8Array(new Int16Array([-128 * 256]).buffer));
-            },
-            "3 byte int"($) {
-                $mol_assert_equal($mol_bigint_encode(128n * 256n), new Uint8Array(new Int32Array([128 * 256]).buffer).slice(0, 3));
-                $mol_assert_equal($mol_bigint_encode(-128n * 256n - 1n), new Uint8Array(new Int32Array([-128 * 256 - 1]).buffer).slice(0, 3));
-                $mol_assert_equal($mol_bigint_encode(128n * 256n ** 2n - 1n), new Uint8Array(new Int32Array([128 * 256 ** 2 - 1]).buffer).slice(0, 3));
-                $mol_assert_equal($mol_bigint_encode(-128n * 256n ** 2n), new Uint8Array(new Int32Array([-128 * 256 ** 2]).buffer).slice(0, 3));
-            },
-            "4 byte int"($) {
-                $mol_assert_equal($mol_bigint_encode(128n * 256n ** 2n), new Uint8Array(new Int32Array([128 * 256 ** 2]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-128n * 256n ** 2n - 1n), new Uint8Array(new Int32Array([-128 * 256 ** 2 - 1]).buffer));
-                $mol_assert_equal($mol_bigint_encode(128n * 256n ** 3n - 1n), new Uint8Array(new Int32Array([128 * 256 ** 3 - 1]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-128n * 256n ** 3n), new Uint8Array(new Int32Array([-128 * 256 ** 3]).buffer));
-            },
-            "8 byte int"($) {
-                $mol_assert_equal($mol_bigint_encode(128n * 256n ** 7n - 1n), new Uint8Array(new BigInt64Array([128n * 256n ** 7n - 1n]).buffer));
-                $mol_assert_equal($mol_bigint_encode(-128n * 256n ** 7n), new Uint8Array(new BigInt64Array([-128n * 256n ** 7n]).buffer));
-            },
-        });
-    })($$ = $_1.$$ || ($_1.$$ = {}));
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    $mol_test({
-        'encode empty'() {
-            $mol_assert_equal($mol_charset_encode(''), new Uint8Array([]));
-        },
-        'encode 1 octet'() {
-            $mol_assert_equal($mol_charset_encode('F'), new Uint8Array([0x46]));
-        },
-        'encode 2 octet'() {
-            $mol_assert_equal($mol_charset_encode('Б'), new Uint8Array([0xd0, 0x91]));
-        },
-        'encode 3 octet'() {
-            $mol_assert_equal($mol_charset_encode('ह'), new Uint8Array([0xe0, 0xa4, 0xb9]));
-        },
-        'encode 4 octet'() {
-            $mol_assert_equal($mol_charset_encode('𐍈'), new Uint8Array([0xf0, 0x90, 0x8d, 0x88]));
-        },
-        'encode surrogate pair'() {
-            $mol_assert_equal($mol_charset_encode('😀'), new Uint8Array([0xf0, 0x9f, 0x98, 0x80]));
-        },
-    });
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    $mol_test({
-        'decode utf8 string'() {
-            const str = 'Hello, ΧΨΩЫ';
-            const encoded = new Uint8Array([72, 101, 108, 108, 111, 44, 32, 206, 167, 206, 168, 206, 169, 208, 171]);
-            $mol_assert_equal($mol_charset_decode(encoded), str);
-            $mol_assert_equal($mol_charset_decode(encoded, 'utf8'), str);
-        },
-        'decode empty string'() {
-            const encoded = new Uint8Array([]);
-            $mol_assert_equal($mol_charset_decode(encoded), '');
-        },
-    });
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($) {
-    function $mol_bigint_decode(buf) {
-        if (buf.length === 8)
-            return new BigInt64Array(buf.buffer, buf.byteOffset, 1)[0];
-        if (buf.length === 4)
-            return BigInt(new Int32Array(buf.buffer, buf.byteOffset, 1)[0]);
-        if (buf.length === 2)
-            return BigInt(new Int16Array(buf.buffer, buf.byteOffset, 1)[0]);
-        if (buf.length === 1)
-            return BigInt(new Int8Array(buf.buffer, buf.byteOffset, 1)[0]);
-        const minus = (buf.at(-1) & 128) ? 255 : 0;
-        let result = 0n;
-        let offset = 0n;
-        for (let i = 0; i < buf.length; i++, offset += 8n) {
-            result |= BigInt(buf[i] ^ minus) << offset;
-        }
-        if (minus)
-            result = (result + 1n) * -1n;
-        return result;
-    }
-    $.$mol_bigint_decode = $mol_bigint_decode;
-})($ || ($ = {}));
-
-;
-"use strict";
-var $;
-(function ($_1) {
-    var $$;
-    (function ($$) {
-        $mol_test({
-            "1 byte int"($) {
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array), 0n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int8Array([1]).buffer)), 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int8Array([-1]).buffer)), -1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int8Array([127]).buffer)), 127n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int8Array([-128]).buffer)), -128n);
-            },
-            "2 byte int"($) {
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int16Array([128]).buffer)), 128n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int16Array([-129]).buffer)), -129n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int16Array([128 * 256 - 1]).buffer)), 128n * 256n - 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int16Array([-128 * 256]).buffer)), -128n * 256n);
-            },
-            "3 byte int"($) {
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([128 * 256]).buffer).slice(0, 3)), 128n * 256n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([-128 * 256 - 1]).buffer).slice(0, 3)), -128n * 256n - 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([128 * 256 ** 2 - 1]).buffer).slice(0, 3)), 128n * 256n ** 2n - 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([-128 * 256 ** 2]).buffer).slice(0, 3)), -128n * 256n ** 2n);
-            },
-            "4 byte int"($) {
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([128 * 256 ** 2]).buffer)), 128n * 256n ** 2n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([-128 * 256 ** 2 - 1]).buffer)), -128n * 256n ** 2n - 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([128 * 256 ** 3 - 1]).buffer)), 128n * 256n ** 3n - 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new Int32Array([-128 * 256 ** 3]).buffer)), -128n * 256n ** 3n);
-            },
-            "8 byte int"($) {
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new BigInt64Array([128n * 256n ** 7n - 1n]).buffer)), 128n * 256n ** 7n - 1n);
-                $mol_assert_equal($mol_bigint_decode(new Uint8Array(new BigInt64Array([-128n * 256n ** 7n]).buffer)), -128n * 256n ** 7n);
-            },
-        });
-    })($$ = $_1.$$ || ($_1.$$ = {}));
-})($ || ($ = {}));
-
 ;
 "use strict";
 var $;
@@ -4908,21 +4595,71 @@ var $;
 ;
 "use strict";
 var $;
-(function ($_1) {
-    var $$;
-    (function ($$) {
-        $mol_test({
-            "Zero int"($) {
-                $mol_assert_equal($mol_bigint_decode($mol_bigint_encode(0n)), 0n);
-            },
-            "Large positive int"($) {
-                $mol_assert_equal($mol_bigint_decode($mol_bigint_encode(12345678901234567890n)), 12345678901234567890n);
-            },
-            "Large negative int"($) {
-                $mol_assert_equal($mol_bigint_decode($mol_bigint_encode(-12345678901234567890n)), -12345678901234567890n);
-            },
-        });
-    })($$ = $_1.$$ || ($_1.$$ = {}));
+(function ($) {
+    $mol_test({
+        'encode empty'() {
+            $mol_assert_equal($mol_charset_encode(''), new Uint8Array([]));
+        },
+        'encode 1 octet'() {
+            $mol_assert_equal($mol_charset_encode('F'), new Uint8Array([0x46]));
+        },
+        'encode 2 octet'() {
+            $mol_assert_equal($mol_charset_encode('Б'), new Uint8Array([0xd0, 0x91]));
+        },
+        'encode 3 octet'() {
+            $mol_assert_equal($mol_charset_encode('ह'), new Uint8Array([0xe0, 0xa4, 0xb9]));
+        },
+        'encode 4 octet'() {
+            $mol_assert_equal($mol_charset_encode('𐍈'), new Uint8Array([0xf0, 0x90, 0x8d, 0x88]));
+        },
+        'encode surrogate pair'() {
+            $mol_assert_equal($mol_charset_encode('😀'), new Uint8Array([0xf0, 0x9f, 0x98, 0x80]));
+        },
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'decode utf8 string'() {
+            const str = 'Hello, ΧΨΩЫ';
+            const encoded = new Uint8Array([72, 101, 108, 108, 111, 44, 32, 206, 167, 206, 168, 206, 169, 208, 171]);
+            $mol_assert_equal($mol_charset_decode(encoded), str);
+            $mol_assert_equal($mol_charset_decode(encoded, 'utf8'), str);
+        },
+        'decode empty string'() {
+            const encoded = new Uint8Array([]);
+            $mol_assert_equal($mol_charset_decode(encoded), '');
+        },
+    });
+})($ || ($ = {}));
+
+;
+"use strict";
+var $;
+(function ($) {
+    $mol_test({
+        'encode empty'() {
+            $mol_assert_equal($mol_charset_decode_from(new Uint8Array([]), 0, 0), ['', 0]);
+        },
+        'encode 1 octet'() {
+            $mol_assert_equal($mol_charset_decode_from(new Uint8Array([0x46]), 0, 1), ['F', 1]);
+        },
+        'encode 2 octet'() {
+            $mol_assert_equal($mol_charset_decode_from(new Uint8Array([0xd0, 0x91]), 0, 1), ['Б', 2]);
+        },
+        'encode 3 octet'() {
+            $mol_assert_equal($mol_charset_decode_from(new Uint8Array([0xe0, 0xa4, 0xb9]), 0, 1), ['ह', 3]);
+        },
+        'encode 4 octet'() {
+            $mol_assert_equal($mol_charset_decode_from(new Uint8Array([0xf0, 0x90, 0x8d, 0x88]), 0, 1), ['𐍈', 4]);
+        },
+        'encode surrogate pair'() {
+            $mol_assert_equal($mol_charset_decode_from(new Uint8Array([0xf0, 0x9f, 0x98, 0x80]), 0, 2), ['😀', 4]);
+        },
+    });
 })($ || ($ = {}));
 
 ;
@@ -4992,23 +4729,25 @@ var $;
             "vary pack float"($) {
                 check(1.5, [fp64, ...new Uint8Array(new Float64Array([1.5]).buffer)]);
             },
+            "vary pack list"($) {
+                check([1, 2, 3], [list | 3, 1, 2, 3]);
+                check([[], [1], [2, 3]], [list | 3, list | 0, list | 1, 1, list | 2, 2, 3]);
+            },
+            "vary pack dedup list"($) {
+                const pair = [1, 2];
+                check([pair, pair], [list | 2, list | 2, 1, 2, link | 0]);
+                const seven = [7];
+                const box = [seven];
+                check([box, box, seven], [list | 3, list | 1, list | 1, 7, link | 1, link | 0]);
+            },
             "vary pack text"($) {
                 check('foo', [text | 3, ...str('foo')]);
                 const long = 'abcdefghijklmnopqrstuvwxyzЖЫ';
-                check(long, [text | l1, 30, ...str(long)]);
+                check(long, [text | l1, 28, ...str(long)]);
             },
             "vary pack dedup text"($) {
                 check(["f", "f"], [list | 2, text | 1, ...str('f'), link | 0]);
             },
-            "vary pack list"($) {
-                check([1, 2, 3], [list | 3, 1, 2, 3]);
-                check([[], [1], [2, 3]], [list | 3, list | 0, list | 1, 1, list | 2, 2, 3]);
-            },
-            "vary pack dedup list"($) {
-                check([[1, 2], [1, 2]], [list | 2, list | 2, 1, 2, link | 0]);
-                check([[[1]], [[1]]], [list | 2, list | 1, list | 1, 1, link | 1]);
-                check([[[7]], [[7]], [7]], [list | 3, list | 1, list | 1, 7, link | 1, link | 0]);
-            },
             "vary pack blob"($) {
                 check(new Uint8Array([1, 255]), [blob | 2, uint | l1, 1, 255]);
                 check(new Int8Array([-128, 127]), [blob | 2, sint | ~l1, -128, 127]);
@@ -5020,23 +4759,26 @@ var $;
                 check(new Float64Array([1.5]), [blob | 8, fp64, ...new Uint8Array(new Float64Array([1.5]).buffer)]);
             },
             "vary pack dedup blob"($) {
-                check([new Uint8Array([1, 2]), new Uint8Array([1, 2])], [list | 2, blob | 2, uint | l1, 1, 2, link | 0]);
+                const part = new Uint8Array([1, 2]);
+                check([part, part], [list | 2, blob | 2, uint | l1, 1, 2, link | 0]);
             },
             "vary pack struct"($) {
-                check({ a: 1, b: 2 }, [tupl | 2, list | 2, text | 1, ...str('a'), text | 1, ...str('b'), 1, 2]);
-                check({ x: {}, y: { a: 1 } }, [tupl | 2, list | 2, text | 1, ...str('x'), text | 1, ...str('y'), tupl | 0, list | 0, tupl | 1, list | 1, text | 1, ...str('a'), 1]);
-                check([{}, { foo: 1 }, { foo: 2 }], [list | 3, tupl | 0, list | 0, tupl | 1, list | 1, text | 3, ...str('foo'), 1, tupl | 1, link | 1, 2]);
+                check({ a: 1, b: 2 }, [tupl | 2, text | 1, ...str('a'), text | 1, ...str('b'), 1, 2]);
+                check({ x: {}, y: { a: 1 } }, [tupl | 2, text | 1, ...str('x'), text | 1, ...str('y'), tupl | 0, tupl | 1, text | 1, ...str('a'), 1]);
             },
-            "vary pack struct dedup"($) {
-                check({ x: 1, y: { x: 2, y: 3 } }, [tupl | 2, list | 2, text | 1, ...str('x'), text | 1, ...str('y'), 1, tupl | 2, link | 2, 2, 3]);
-                check([{ x: 1 }, { x: 1 }], [list | 2, tupl | 1, list | 1, text | 1, ...str('x'), 1, link | 2]);
-                check({ x: { x: 1, y: 2 }, y: { x: 1, y: 2 } }, [tupl | 2, list | 2, text | 1, ...str('x'), text | 1, ...str('y'), tupl | 2, link | 2, 1, 2, link | 3]);
+            "vary pack struct full dedup"($) {
+                const item = { x: 1 };
+                check([item, item], [list | 2, tupl | 1, text | 1, ...str('x'), 1, link | 1]);
             },
             "vary pack Map"($) {
-                check(new Map([['foo', 1], [2, 'bar']]), [tupl | 2, list | 2, text | 4, ...str('keys'), text | 4, ...str('vals'), list | 2, text | 3, ...str('foo'), 2, list | 2, 1, text | 3, ...str('bar')]);
+                check(new Map([['foo', 1], [2, 'bar']]), [tupl | 2, text | 4, ...str('keys'), text | 4, ...str('vals'), list | 2, text | 3, ...str('foo'), 2, list | 2, 1, text | 3, ...str('bar')]);
             },
             "vary pack Set"($) {
-                check(new Set([7, 'foo']), [tupl | 1, list | 1, text | 4, ...str('vals'), list | 2, 7, text | 3, ...str('foo')]);
+                check(new Set([7, 'foo']), [tupl | 1, text | 4, ...str('vals'), list | 2, 7, text | 3, ...str('foo')]);
+            },
+            "vary pack Date"($) {
+                const date = new Date('2025-01-02T03:04:05.678');
+                check(date, [tupl | 1, text | 9, ...str('unix_time'), fp64, ...new Uint8Array(new Float64Array([date.valueOf() / 1000]).buffer)]);
             },
             "vary pack custom class"($) {
                 class Foo {
@@ -5051,11 +4793,8 @@ var $;
                         return [this.a, this.b].values();
                     }
                 }
-                $mol_vary.type((a = 0, b = 0) => new Foo(a, b), foo => [
-                    ['a', 'b'],
-                    [foo.a, foo.b],
-                ]);
-                check(new Foo(1, 2), [tupl | 2, list | 2, text | 1, ...str('a'), text | 1, ...str('b'), 1, 2]);
+                $mol_vary.type(['a', 'b'], (a = 0, b = 0) => new Foo(a, b), foo => [foo.a, foo.b]);
+                check(new Foo(1, 2), [tupl | 2, text | 1, ...str('a'), text | 1, ...str('b'), 1, 2]);
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));