mol_vary 0.0.41 → 0.0.43

package/node.test.js

@@ -2327,14 +2327,23 @@ var $;
         $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["fp16"] = 'H'.charCodeAt(0)] = "fp16";
+        $mol_vary_spec[$mol_vary_spec["fp32"] = 'S'.charCodeAt(0)] = "fp32";
+        $mol_vary_spec[$mol_vary_spec["fp64"] = 'D'.charCodeAt(0)] = "fp64";
+        $mol_vary_spec[$mol_vary_spec["f128"] = 'Q'.charCodeAt(0)] = "f128";
+        $mol_vary_spec[$mol_vary_spec["f256"] = 'O'.charCodeAt(0)] = "f256";
     })($mol_vary_spec = $.$mol_vary_spec || ($.$mol_vary_spec = {}));
-    let buffer = new Uint8Array(256);
-    let pack = new DataView(buffer.buffer);
-    class $mol_vary extends Object {
-        static pack(data) {
+    const pojo_maker = (keys) => (vals) => {
+        const obj = {};
+        for (let i = 0; i < keys.length; ++i)
+            obj[keys[i]] = vals[i];
+        return obj;
+    };
+    class $mol_vary_class extends Object {
+        lean_symbol = Symbol('$mol_vary_lean');
+        array = new Uint8Array(256);
+        buffer = new DataView(this.array.buffer);
+        pack(data) {
             let pos = 0;
             let capacity = 9;
             const offsets = new Map();
@@ -2343,19 +2352,19 @@ var $;
                 if (size < 0)
                     return;
                 capacity += size;
-                if (buffer.byteLength >= capacity)
+                if (this.array.byteLength >= capacity)
                     return;
                 const buffer2 = new Uint8Array(Math.ceil(capacity / 4096) * 4096);
-                buffer2.set(buffer);
-                buffer = buffer2;
-                pack = new DataView(buffer.buffer);
+                buffer2.set(this.array);
+                this.array = buffer2;
+                this.buffer = new DataView(this.array.buffer);
             };
             const release = (size) => {
                 capacity -= size;
             };
             const dump_unum = (tip, val) => {
                 if (val < $mol_vary_len.L1) {
-                    buffer[pos++] = tip | Number(val);
+                    this.array[pos++] = tip | Number(val);
                     release(8);
                     return;
                 }
@@ -2365,25 +2374,25 @@ var $;
                         return dump_unum($mol_vary_tip.link, offset);
                 }
                 if (val < 2 ** 8) {
-                    buffer[pos++] = tip | $mol_vary_len.L1;
-                    buffer[pos++] = Number(val);
+                    this.array[pos++] = tip | $mol_vary_len.L1;
+                    this.array[pos++] = Number(val);
                     release(7);
                 }
                 else if (val < 2 ** 16) {
-                    buffer[pos++] = tip | $mol_vary_len.L2;
-                    pack.setUint16(pos, Number(val), true);
+                    this.array[pos++] = tip | $mol_vary_len.L2;
+                    this.buffer.setUint16(pos, Number(val), true);
                     pos += 2;
                     release(6);
                 }
                 else if (val < 2 ** 32) {
-                    buffer[pos++] = tip | $mol_vary_len.L4;
-                    pack.setUint32(pos, Number(val), true);
+                    this.array[pos++] = tip | $mol_vary_len.L4;
+                    this.buffer.setUint32(pos, Number(val), true);
                     pos += 4;
                     release(4);
                 }
                 else if (val < 2n ** 64n) {
-                    buffer[pos++] = tip | $mol_vary_len.L8;
-                    pack.setBigUint64(pos, BigInt(val), true);
+                    this.array[pos++] = tip | $mol_vary_len.L8;
+                    this.buffer.setBigUint64(pos, BigInt(val), true);
                     pos += 8;
                 }
                 else {
@@ -2394,7 +2403,7 @@ var $;
             };
             const dump_snum = (val) => {
                 if (val > -$mol_vary_len.L1) {
-                    buffer[pos++] = Number(val);
+                    this.array[pos++] = Number(val);
                     release(8);
                     return;
                 }
@@ -2402,25 +2411,25 @@ var $;
                 if (offset !== undefined)
                     return dump_unum($mol_vary_tip.link, offset);
                 if (val >= -(2 ** 7)) {
-                    buffer[pos++] = -$mol_vary_len.L1;
-                    buffer[pos++] = Number(val);
+                    this.array[pos++] = -$mol_vary_len.L1;
+                    this.array[pos++] = Number(val);
                     release(7);
                 }
                 else if (val >= -(2 ** 15)) {
-                    buffer[pos++] = -$mol_vary_len.L2;
-                    pack.setInt16(pos, Number(val), true);
+                    this.array[pos++] = -$mol_vary_len.L2;
+                    this.buffer.setInt16(pos, Number(val), true);
                     pos += 2;
                     release(6);
                 }
                 else if (val >= -(2 ** 31)) {
-                    buffer[pos++] = -$mol_vary_len.L4;
-                    pack.setInt32(pos, Number(val), true);
+                    this.array[pos++] = -$mol_vary_len.L4;
+                    this.buffer.setInt32(pos, Number(val), true);
                     pos += 4;
                     release(4);
                 }
                 else if (val >= -(2n ** 63n)) {
-                    buffer[pos++] = -$mol_vary_len.L8;
-                    pack.setBigInt64(pos, BigInt(val), true);
+                    this.array[pos++] = -$mol_vary_len.L8;
+                    this.buffer.setBigInt64(pos, BigInt(val), true);
                     pos += 8;
                 }
                 else {
@@ -2433,17 +2442,17 @@ var $;
                 if (buf.byteLength > 264)
                     $mol_fail(new Error('Number too high', { cause: { val } }));
                 acquire(buf.byteLength - 7);
-                buffer[pos++] = -$mol_vary_len.LA;
-                buffer[pos++] = buf.byteLength - 9;
-                buffer.set(buf, pos);
+                this.array[pos++] = -$mol_vary_len.LA;
+                this.array[pos++] = buf.byteLength - 9;
+                this.array.set(buf, pos);
                 pos += buf.byteLength;
             };
             const dump_float = (val) => {
                 const offset = offsets.get(val);
                 if (offset !== undefined)
                     return dump_unum($mol_vary_tip.link, offset);
-                buffer[pos++] = $mol_vary_spec.fp64;
-                pack.setFloat64(pos, val, true);
+                this.array[pos++] = $mol_vary_spec.fp64;
+                this.buffer.setFloat64(pos, val, true);
                 pos += 8;
                 offsets.set(val, offsets.size);
             };
@@ -2453,7 +2462,7 @@ var $;
                     return dump_unum($mol_vary_tip.link, offset);
                 dump_unum($mol_vary_tip.text, val.length);
                 acquire(val.length * 3);
-                const len = $mol_charset_encode_to(val, buffer, pos);
+                const len = $mol_charset_encode_to(val, this.array, pos);
                 pos += len;
                 release(val.length * 3 - len);
                 offsets.set(val, offsets.size);
@@ -2466,31 +2475,31 @@ var $;
                 dump_unum($mol_vary_tip.blob, val.byteLength);
                 acquire(1 + val.byteLength);
                 if (val instanceof Uint8Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L1;
+                    this.array[pos++] = $mol_vary_tip.uint | $mol_vary_len.L1;
                 else if (val instanceof Uint16Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L2;
+                    this.array[pos++] = $mol_vary_tip.uint | $mol_vary_len.L2;
                 else if (val instanceof Uint32Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L4;
+                    this.array[pos++] = $mol_vary_tip.uint | $mol_vary_len.L4;
                 else if (val instanceof BigUint64Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L8;
+                    this.array[pos++] = $mol_vary_tip.uint | $mol_vary_len.L8;
                 else if (val instanceof Int8Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L1;
+                    this.array[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L1;
                 else if (val instanceof Int16Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L2;
+                    this.array[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L2;
                 else if (val instanceof Int32Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L4;
+                    this.array[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L4;
                 else if (val instanceof BigInt64Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L8;
+                    this.array[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L8;
                 else if (typeof Float16Array === 'function' && val instanceof Float16Array)
-                    buffer[pos++] = $mol_vary_spec.fp16;
+                    this.array[pos++] = $mol_vary_spec.fp16;
                 else if (val instanceof Float32Array)
-                    buffer[pos++] = $mol_vary_spec.fp32;
+                    this.array[pos++] = $mol_vary_spec.fp32;
                 else if (val instanceof Float64Array)
-                    buffer[pos++] = $mol_vary_spec.fp64;
+                    this.array[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);
-                buffer.set(src, pos);
+                this.array.set(src, pos);
                 pos += val.byteLength;
                 offsets.set(val, offsets.size);
             };
@@ -2524,7 +2533,7 @@ var $;
                 const offset = offsets.get(val);
                 if (offset !== undefined)
                     return dump_unum($mol_vary_tip.link, offset);
-                const [keys, vals] = val[$.$mol_vary_lean]?.(val) ?? [shape(val), Object.values(val)];
+                const [keys, 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);
@@ -2541,12 +2550,12 @@ var $;
             const dump = (val) => {
                 switch (typeof val) {
                     case 'undefined': {
-                        buffer[pos++] = $mol_vary_spec.both;
+                        this.array[pos++] = $mol_vary_spec.both;
                         release(8);
                         return;
                     }
                     case 'boolean': {
-                        buffer[pos++] = val ? $mol_vary_spec.true : $mol_vary_spec.fake;
+                        this.array[pos++] = val ? $mol_vary_spec.true : $mol_vary_spec.fake;
                         release(8);
                         return;
                     }
@@ -2567,7 +2576,7 @@ var $;
                     case 'object': {
                         if (!val) {
                             release(8);
-                            return buffer[pos++] = $mol_vary_spec.none;
+                            return this.array[pos++] = $mol_vary_spec.none;
                         }
                         if (ArrayBuffer.isView(val))
                             return dump_buffer(val);
@@ -2581,10 +2590,10 @@ var $;
             dump(data);
             if (pos !== capacity)
                 $mol_fail(new Error('Wrong reserved capacity', { cause: { capacity, size: pos, data } }));
-            return buffer.slice(0, pos);
+            return this.array.slice(0, pos);
         }
-        static take(buffer) {
-            const pack = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        take(array) {
+            const buffer = new DataView(array.buffer, array.byteOffset, array.byteLength);
             const stream = [];
             let pos = 0;
             const read_unum = (kind) => {
@@ -2594,18 +2603,18 @@ var $;
                     return num;
                 let res = 0;
                 if (num === $mol_vary_len.L1) {
-                    res = pack.getUint8(pos++);
+                    res = buffer.getUint8(pos++);
                 }
                 else if (num === $mol_vary_len.L2) {
-                    res = pack.getUint16(pos, true);
+                    res = buffer.getUint16(pos, true);
                     pos += 2;
                 }
                 else if (num === $mol_vary_len.L4) {
-                    res = pack.getUint32(pos, true);
+                    res = buffer.getUint32(pos, true);
                     pos += 4;
                 }
                 else if (num === $mol_vary_len.L8) {
-                    res = pack.getBigUint64(pos, true);
+                    res = buffer.getBigUint64(pos, true);
                     if (res <= Number.MAX_SAFE_INTEGER)
                         res = Number(res);
                     pos += 8;
@@ -2618,30 +2627,30 @@ var $;
                 return res;
             };
             const read_snum = (kind) => {
-                const num = pack.getInt8(pos++);
+                const num = buffer.getInt8(pos++);
                 if (num > -$mol_vary_len.L1)
                     return num;
                 let res = 0;
                 if (num === -$mol_vary_len.L1) {
-                    res = pack.getInt8(pos++);
+                    res = buffer.getInt8(pos++);
                 }
                 else if (num === -$mol_vary_len.L2) {
-                    res = pack.getInt16(pos, true);
+                    res = buffer.getInt16(pos, true);
                     pos += 2;
                 }
                 else if (num === -$mol_vary_len.L4) {
-                    res = pack.getInt32(pos, true);
+                    res = buffer.getInt32(pos, true);
                     pos += 4;
                 }
                 else if (num === -$mol_vary_len.L8) {
-                    res = pack.getBigInt64(pos, true);
+                    res = buffer.getBigInt64(pos, true);
                     if (res >= Number.MIN_SAFE_INTEGER && res <= Number.MAX_SAFE_INTEGER)
                         res = Number(res);
                     pos += 8;
                 }
                 else if (num === -$mol_vary_len.LA) {
-                    const len = pack.getUint8(pos++) + 9;
-                    res = $mol_bigint_decode(new Uint8Array(pack.buffer, pack.byteOffset + pos, len));
+                    const len = buffer.getUint8(pos++) + 9;
+                    res = $mol_bigint_decode(new Uint8Array(buffer.buffer, buffer.byteOffset + pos, len));
                     pos += len;
                 }
                 else {
@@ -2652,20 +2661,20 @@ var $;
             };
             const read_text = (kind) => {
                 const len = read_unum(kind);
-                const [text, bytes] = $mol_charset_decode_from(buffer, pack.byteOffset + pos, len);
+                const [text, bytes] = $mol_charset_decode_from(array, buffer.byteOffset + pos, len);
                 pos += bytes;
                 stream.push(text);
                 return text;
             };
             const read_buffer = (len, TypedArray) => {
-                const bin = new TypedArray(buffer.slice(pos, pos + len).buffer);
+                const bin = new TypedArray(array.slice(pos, pos + len).buffer);
                 pos += len;
                 stream.push(bin);
                 return bin;
             };
             const read_blob = (kind) => {
                 const len = read_unum(kind);
-                const kind_item = pack.getUint8(pos++);
+                const kind_item = buffer.getUint8(pos++);
                 switch (kind_item) {
                     case $mol_vary_len.L1: return read_buffer(len, Uint8Array);
                     case $mol_vary_len.L2: return read_buffer(len, Uint16Array);
@@ -2705,13 +2714,8 @@ var $;
                 const node = this.rich_node(keys);
                 let rich = node.get(null);
                 if (!rich)
-                    node.set(null, rich = (...vals) => {
-                        const obj = {};
-                        for (let i = 0; i < len; ++i)
-                            obj[keys[i]] = vals[i];
-                        return obj;
-                    });
-                const obj = rich(...vals);
+                    node.set(null, rich = pojo_maker(keys));
+                const obj = rich(vals);
                 stream.push(obj);
                 return obj;
             };
@@ -2730,19 +2734,19 @@ var $;
                         ++pos;
                         return undefined;
                     case $mol_vary_spec.fp64: {
-                        const val = pack.getFloat64(++pos, true);
+                        const val = buffer.getFloat64(++pos, true);
                         stream.push(val);
                         pos += 8;
                         return val;
                     }
                     case $mol_vary_spec.fp32: {
-                        const val = pack.getFloat32(++pos, true);
+                        const val = buffer.getFloat32(++pos, true);
                         stream.push(val);
                         pos += 4;
                         return val;
                     }
                     case $mol_vary_spec.fp16: {
-                        const val = pack.getFloat16(++pos, true);
+                        const val = buffer.getFloat16(++pos, true);
                         stream.push(val);
                         pos += 2;
                         return val;
@@ -2752,7 +2756,7 @@ var $;
                 }
             };
             const read_vary = () => {
-                const kind = pack.getUint8(pos);
+                const kind = buffer.getUint8(pos);
                 const tip = kind & 0b111_00000;
                 switch (tip) {
                     case $mol_vary_tip.uint: return read_unum(kind);
@@ -2767,14 +2771,21 @@ var $;
                 }
             };
             const result = read_vary();
-            if (pos !== buffer.byteLength)
-                $mol_fail(new Error('Buffer too large', { cause: { size: buffer.byteLength, taken: pos, result } }));
+            if (pos !== array.byteLength)
+                $mol_fail(new Error('Buffer too large', { cause: { size: array.byteLength, taken: pos, result } }));
             return result;
         }
-        static rich_index = new Map([
+        rich_index = new Map([
             [null, () => ({})]
         ]);
-        static rich_node(keys) {
+        room() {
+            const room = new $mol_vary_class;
+            Object.setPrototypeOf(room, this);
+            const index_clone = (map) => new Map([...map].map(([k, v]) => [k, k === null ? v : index_clone(v)]));
+            room.rich_index = index_clone(this.rich_index);
+            return room;
+        }
+        rich_node(keys) {
             let node = this.rich_index;
             for (const key of keys) {
                 let sub = node.get(key);
@@ -2785,33 +2796,72 @@ var $;
             }
             return node;
         }
-        static type(Class, keys, lean, rich) {
+        lean_find(val) {
+            const lean = val[this.lean_symbol];
+            if (lean)
+                return lean;
+            const sup = Object.getPrototypeOf(this);
+            if (sup === Object.prototype)
+                return;
+            return sup.lean_find(val);
+        }
+        type({ type, keys, rich, lean }) {
             this.rich_node(keys).set(null, rich);
-            Class.prototype[$.$mol_vary_lean] = (val) => [keys, lean(val)];
+            type.prototype[this.lean_symbol] = (val) => [keys, lean(val)];
         }
     }
-    $.$mol_vary = $mol_vary;
-    $.$mol_vary_lean = Symbol.for('$mol_vary_lean');
-    $mol_vary.type(Map, ['keys', 'vals'], obj => [[...obj.keys()], [...obj.values()]], (keys, vals) => new Map(keys.map((k, i) => [k, vals[i]])));
-    $mol_vary.type(Set, ['set'], obj => [[...obj.values()]], vals => new Set(vals));
-    $mol_vary.type(Date, ['unix_time'], obj => [obj.valueOf() / 1000], ts => new Date(ts * 1000));
-    $mol_vary.type($mol_dom.Element, ['elem', 'keys', 'vals', 'kids'], node => {
-        const attrs = [...node.attributes];
-        const kids = [...node.childNodes].map(kid => kid instanceof $mol_dom.Text ? kid.nodeValue : kid);
-        return [node.nodeName, attrs.map(attr => attr.nodeName), attrs.map(attr => attr.nodeValue), kids];
-    }, (name, keys, vals, kids) => {
-        const el = $mol_dom.document.createElement(name);
-        for (let i = 0; i < keys.length; ++i)
-            el.setAttribute(keys[i], vals[i]);
-        for (let kid of kids) {
-            if (typeof kid === 'string')
-                kid = $mol_dom.document.createTextNode(kid);
-            el.appendChild(kid);
-        }
-        return el;
+    $.$mol_vary_class = $mol_vary_class;
+    $.$mol_vary = new $mol_vary_class;
+    $.$mol_vary.type({
+        type: Map,
+        keys: ['keys', 'vals'],
+        lean: obj => [[...obj.keys()], [...obj.values()]],
+        rich: ([keys, vals]) => new Map(keys.map((k, i) => [k, vals[i]])),
+    });
+    $.$mol_vary.type({
+        type: Set,
+        keys: ['set'],
+        lean: obj => [[...obj.values()]],
+        rich: ([vals]) => new Set(vals),
+    });
+    $.$mol_vary.type({
+        type: Date,
+        keys: ['unix_time'],
+        lean: obj => [obj.valueOf() / 1000],
+        rich: ([ts]) => new Date(ts * 1000),
+    });
+    $.$mol_vary.type({
+        type: $mol_dom.Element,
+        keys: ['elem', 'keys', 'vals', 'kids'],
+        lean: node => {
+            const attrs = [...node.attributes];
+            const kids = [...node.childNodes].map(kid => kid instanceof $mol_dom.Text ? kid.nodeValue : kid);
+            return [node.nodeName, attrs.map(attr => attr.nodeName), attrs.map(attr => attr.nodeValue), kids];
+        },
+        rich: ([name, keys, vals, kids]) => {
+            const el = $mol_dom.document.createElement(name);
+            for (let i = 0; i < keys.length; ++i)
+                el.setAttribute(keys[i], vals[i]);
+            for (let kid of kids) {
+                if (typeof kid === 'string')
+                    kid = $mol_dom.document.createTextNode(kid);
+                el.appendChild(kid);
+            }
+            return el;
+        },
+    });
+    $.$mol_vary.type({
+        type: $mol_dom.Comment,
+        keys: ['#comment'],
+        lean: node => [node.nodeValue],
+        rich: ([text]) => $mol_dom.document.createComment(text),
+    });
+    $.$mol_vary.type({
+        type: $mol_dom.ProcessingInstruction,
+        keys: ['target', 'text'],
+        lean: node => [node.nodeName, node.nodeValue],
+        rich: ([target, text]) => $mol_dom.document.createProcessingInstruction(target, text),
     });
-    $mol_vary.type($mol_dom.Comment, ['#comment'], node => [node.nodeValue], text => $mol_dom.document.createComment(text));
-    $mol_vary.type($mol_dom.ProcessingInstruction, ['target', 'text'], node => [node.nodeName, node.nodeValue], (target, text) => $mol_dom.document.createProcessingInstruction(target, text));
 })($ || ($ = {}));
 
 ;
@@ -4886,10 +4936,10 @@ var $;
         const { none, both, fp16, fp32, fp64 } = $mol_vary_spec;
         const { L1, L2, L4, L8, LA } = $mol_vary_len;
         const str = $mol_charset_encode;
-        function check(vary, ideal) {
-            const pack = $mol_vary.pack(vary);
+        function check(vary, ideal, Vary = $mol_vary) {
+            const pack = Vary.pack(vary);
             $mol_assert_equal(pack, new Uint8Array(ideal));
-            $mol_assert_equal($mol_vary.take(pack), vary);
+            $mol_assert_equal(Vary.take(pack), vary);
         }
         $mol_test({
             "vary pack logical"($) {
@@ -5066,7 +5116,7 @@ var $;
                     tupl | 2, list | 2, text | 6, ...str('target'), text | 4, ...str('text'), text | 3, ...str('foo'), text | 3, ...str('bar'),
                 ]);
             },
-            "vary pack custom class"($) {
+            "vary pack custom types in rooms"($) {
                 class Foo {
                     a;
                     b;
@@ -5079,8 +5129,16 @@ var $;
                         return [this.a, this.b].values();
                     }
                 }
-                $mol_vary.type(Foo, ['custom_a', 'custom_b'], foo => [foo.a, foo.b], (a = 0, b = 0) => new Foo(a, b));
-                check(new Foo(1, 2), [tupl | 2, list | 2, text | 8, ...str('custom_a'), text | 8, ...str('custom_b'), 1, 2]);
+                const Vary = $mol_vary.room();
+                Vary.type({
+                    type: Foo,
+                    keys: ['summ', 'diff'],
+                    lean: foo => [foo.a + foo.b, foo.a - foo.b],
+                    rich: ([summ, diff]) => new Foo((summ + diff) / 2, (summ - diff) / 2),
+                });
+                check(new Foo(4, 2), [tupl | 2, list | 2, text | 4, ...str('summ'), text | 4, ...str('diff'), 6, 2], Vary);
+                $mol_assert_equal($mol_vary.take($mol_vary.pack(new Foo(4, 2))), { a: 4, b: 2 });
+                $mol_assert_equal(Vary.take(Vary.pack(new Map([[1, 2]]))), new Map([[1, 2]]));
             },
         });
     })($$ = $_1.$$ || ($_1.$$ = {}));