mol_vary 0.0.27 → 0.0.28

package/node.mjs

@@ -28,6 +28,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var $ = ( typeof module === 'object' ) ? ( module['export'+'s'] = globalThis ) : globalThis
 $.$$ = $
 
+;
+"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 $;
@@ -95,6 +117,32 @@ var $;
     $.$mol_charset_encode_size = $mol_charset_encode_size;
 })($ || ($ = {}));
 
+;
+"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";
 
@@ -2274,12 +2322,14 @@ var $;
         $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_len;
+    (function ($mol_vary_len) {
+        $mol_vary_len[$mol_vary_len["L1"] = 28] = "L1";
+        $mol_vary_len[$mol_vary_len["L2"] = 29] = "L2";
+        $mol_vary_len[$mol_vary_len["L4"] = 30] = "L4";
+        $mol_vary_len[$mol_vary_len["L8"] = 31] = "L8";
+        $mol_vary_len[$mol_vary_len["LA"] = 32] = "LA";
+    })($mol_vary_len = $.$mol_vary_len || ($.$mol_vary_len = {}));
     let $mol_vary_spec;
     (function ($mol_vary_spec) {
         $mol_vary_spec[$mol_vary_spec["none"] = 'N'.charCodeAt(0)] = "none";
@@ -2311,66 +2361,76 @@ var $;
             const release = (size) => {
                 capacity -= size;
             };
-            const dump_snum = (val) => {
-                if (val >= -28) {
-                    buffer[pos++] = Number(val);
+            const dump_bint = (val) => {
+                const buf = $mol_bigint_encode(val);
+                acquire(buf.byteLength - 7);
+                if (buf.byteLength > 264)
+                    $mol_fail(new Error('Number too high', { cause: { val } }));
+                buffer[pos++] = -$mol_vary_len.LA;
+                buffer[pos++] = buf.byteLength - 9;
+                buffer.set(buf, pos);
+                pos += buf.byteLength;
+            };
+            const dump_unum = (tip, val) => {
+                if (val < $mol_vary_len.L1) {
+                    buffer[pos++] = tip | Number(val);
                     release(8);
                 }
-                else if (val >= -(2 ** 7)) {
-                    buffer[pos++] = ~$.$mol_vary_len[1];
+                else if (val < 2 ** 8) {
+                    buffer[pos++] = tip | $mol_vary_len.L1;
                     buffer[pos++] = Number(val);
                     release(7);
                 }
-                else if (val >= -(2 ** 15)) {
-                    buffer[pos++] = ~$.$mol_vary_len[2];
-                    pack.setInt16(pos, Number(val), true);
+                else if (val < 2 ** 16) {
+                    buffer[pos++] = tip | $mol_vary_len.L2;
+                    pack.setUint16(pos, Number(val), true);
                     pos += 2;
                     release(6);
                 }
-                else if (val >= -(2 ** 31)) {
-                    buffer[pos++] = ~$.$mol_vary_len[4];
-                    pack.setInt32(pos, Number(val), true);
+                else if (val < 2 ** 32) {
+                    buffer[pos++] = tip | $mol_vary_len.L4;
+                    pack.setUint32(pos, Number(val), true);
                     pos += 4;
                     release(4);
                 }
-                else if (val >= -(2n ** 63n)) {
-                    buffer[pos++] = ~$.$mol_vary_len[8];
-                    pack.setBigInt64(pos, BigInt(val), true);
+                else if (val < 2n ** 64n) {
+                    buffer[pos++] = tip | $mol_vary_len.L8;
+                    pack.setBigUint64(pos, BigInt(val), true);
                     pos += 8;
                 }
                 else {
-                    $mol_fail(new Error('Number too low', { cause: val }));
+                    dump_bint(val);
                 }
             };
-            const dump_unum = (tip, val) => {
-                if (val < 28) {
-                    buffer[pos++] = tip | Number(val);
+            const dump_snum = (val) => {
+                if (val > -$mol_vary_len.L1) {
+                    buffer[pos++] = Number(val);
                     release(8);
                 }
-                else if (val < 2 ** 8) {
-                    buffer[pos++] = tip | $.$mol_vary_len[1];
+                else if (val >= -(2 ** 7)) {
+                    buffer[pos++] = -$mol_vary_len.L1;
                     buffer[pos++] = Number(val);
                     release(7);
                 }
-                else if (val < 2 ** 16) {
-                    buffer[pos++] = tip | $.$mol_vary_len[2];
-                    pack.setUint16(pos, Number(val), true);
+                else if (val >= -(2 ** 15)) {
+                    buffer[pos++] = -$mol_vary_len.L2;
+                    pack.setInt16(pos, Number(val), true);
                     pos += 2;
                     release(6);
                 }
-                else if (val < 2 ** 32) {
-                    buffer[pos++] = tip | $.$mol_vary_len[4];
-                    pack.setUint32(pos, Number(val), true);
+                else if (val >= -(2 ** 31)) {
+                    buffer[pos++] = -$mol_vary_len.L4;
+                    pack.setInt32(pos, Number(val), true);
                     pos += 4;
                     release(4);
                 }
-                else if (val < 2n ** 64n) {
-                    buffer[pos++] = tip | $.$mol_vary_len[8];
-                    pack.setBigUint64(pos, BigInt(val), true);
+                else if (val >= -(2n ** 63n)) {
+                    buffer[pos++] = -$mol_vary_len.L8;
+                    pack.setBigInt64(pos, BigInt(val), true);
                     pos += 8;
                 }
                 else {
-                    $mol_fail(new Error('Number too high', { cause: { val } }));
+                    dump_bint(val);
                 }
             };
             const dump_string = (val) => {
@@ -2396,21 +2456,23 @@ var $;
                 }
                 dump_unum($mol_vary_tip.blob, val.byteLength);
                 if (val instanceof Uint8Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $.$mol_vary_len[1];
+                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L1;
                 else if (val instanceof Uint16Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $.$mol_vary_len[2];
+                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L2;
                 else if (val instanceof Uint32Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $.$mol_vary_len[4];
+                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L4;
                 else if (val instanceof BigUint64Array)
-                    buffer[pos++] = $mol_vary_tip.uint | $.$mol_vary_len[8];
+                    buffer[pos++] = $mol_vary_tip.uint | $mol_vary_len.L8;
                 else if (val instanceof Int8Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$.$mol_vary_len[1];
+                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L1;
                 else if (val instanceof Int16Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$.$mol_vary_len[2];
+                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L2;
                 else if (val instanceof Int32Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$.$mol_vary_len[4];
+                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L4;
                 else if (val instanceof BigInt64Array)
-                    buffer[pos++] = $mol_vary_tip.sint | ~$.$mol_vary_len[8];
+                    buffer[pos++] = $mol_vary_tip.sint | ~$mol_vary_len.L8;
+                else if (typeof Float16Array === 'function' && val instanceof Float16Array)
+                    buffer[pos++] = $mol_vary_spec.fp16;
                 else if (val instanceof Float32Array)
                     buffer[pos++] = $mol_vary_spec.fp32;
                 else if (val instanceof Float64Array)
@@ -2506,21 +2568,21 @@ var $;
             const read_unum = (kind) => {
                 ++pos;
                 const num = kind & 0b11111;
-                if (num < 28)
+                if (num < $mol_vary_len.L1)
                     return num;
                 let res = 0;
-                if (num === 28) {
+                if (num === $mol_vary_len.L1) {
                     res = pack.getUint8(pos++);
                 }
-                else if (num === 29) {
+                else if (num === $mol_vary_len.L2) {
                     res = pack.getUint16(pos, true);
                     pos += 2;
                 }
-                else if (num === 30) {
+                else if (num === $mol_vary_len.L4) {
                     res = pack.getUint32(pos, true);
                     pos += 4;
                 }
-                else if (num === 31) {
+                else if (num === $mol_vary_len.L8) {
                     res = pack.getBigUint64(pos, true);
                     if (res <= Number.MAX_SAFE_INTEGER)
                         res = Number(res);
@@ -2533,27 +2595,31 @@ var $;
             };
             const read_snum = (kind) => {
                 const num = pack.getInt8(pos++);
-                if (num >= -28)
+                if (num > -$mol_vary_len.L1)
                     return num;
                 let res = 0;
-                if (num === -29) {
-                    res = pack.getInt8(pos);
-                    pos += 1;
+                if (num === -$mol_vary_len.L1) {
+                    res = pack.getInt8(pos++);
                 }
-                else if (num === -30) {
+                else if (num === -$mol_vary_len.L2) {
                     res = pack.getInt16(pos, true);
                     pos += 2;
                 }
-                else if (num === -31) {
+                else if (num === -$mol_vary_len.L4) {
                     res = pack.getInt32(pos, true);
                     pos += 4;
                 }
-                else if (num === -32) {
+                else if (num === -$mol_vary_len.L8) {
                     res = pack.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));
+                    pos += len;
+                }
                 else {
                     $mol_fail(new Error('Unsupported snum', { cause: { num } }));
                 }
@@ -2578,14 +2644,14 @@ var $;
                 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_len.L1: return read_buffer(len, Uint8Array);
+                    case $mol_vary_len.L2: return read_buffer(len, Uint16Array);
+                    case $mol_vary_len.L4: return read_buffer(len, Uint32Array);
+                    case $mol_vary_len.L8: return read_buffer(len, BigUint64Array);
+                    case ~$mol_vary_len.L1 + 256: return read_buffer(len, Int8Array);
+                    case ~$mol_vary_len.L2 + 256: return read_buffer(len, Int16Array);
+                    case ~$mol_vary_len.L4 + 256: return read_buffer(len, Int32Array);
+                    case ~$mol_vary_len.L8 + 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);