libshv-js 3.16.1 → 3.20.0

package/{src/chainpack.ts → dist/chainpack.js}

@@ -1,64 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHAINPACK_PROTOCOL_TYPE = exports.ChainPackWriter = exports.ChainPackReader = exports.fromChainPack = exports.toChainPack = void 0;
 /* eslint-disable no-bitwise */
-import {utf8ToString} from './cpon';
-import {type RpcValue, type RpcValueType, type DateTime, Decimal, Double, type IMap, type Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, shvMapType} from './rpcvalue';
-import {UnpackContext, PackContext} from './cpcontext';
-
-enum PackingSchema {
-    IntThreshold = 64,
-    Null = 128,
-    UInt = 129,
-    Int = 130,
-    Double = 131,
-    Bool = 132,
-    Blob = 133,
-    String = 134,
-    List = 136,
-    Map = 137,
-    IMap = 138,
-    MetaMap = 139,
-    Decimal = 140,
-    DateTime = 141,
-    CString = 142,
-    False = 253,
-    True = 254,
-    Term = 255,
-}
-
+const cpon_1 = require("./cpon");
+const rpcvalue_1 = require("./rpcvalue");
+const cpcontext_1 = require("./cpcontext");
+var PackingSchema;
+(function (PackingSchema) {
+    PackingSchema[PackingSchema["IntThreshold"] = 64] = "IntThreshold";
+    PackingSchema[PackingSchema["Null"] = 128] = "Null";
+    PackingSchema[PackingSchema["UInt"] = 129] = "UInt";
+    PackingSchema[PackingSchema["Int"] = 130] = "Int";
+    PackingSchema[PackingSchema["Double"] = 131] = "Double";
+    PackingSchema[PackingSchema["Bool"] = 132] = "Bool";
+    PackingSchema[PackingSchema["Blob"] = 133] = "Blob";
+    PackingSchema[PackingSchema["String"] = 134] = "String";
+    PackingSchema[PackingSchema["List"] = 136] = "List";
+    PackingSchema[PackingSchema["Map"] = 137] = "Map";
+    PackingSchema[PackingSchema["IMap"] = 138] = "IMap";
+    PackingSchema[PackingSchema["MetaMap"] = 139] = "MetaMap";
+    PackingSchema[PackingSchema["Decimal"] = 140] = "Decimal";
+    PackingSchema[PackingSchema["DateTime"] = 141] = "DateTime";
+    PackingSchema[PackingSchema["CString"] = 142] = "CString";
+    PackingSchema[PackingSchema["False"] = 253] = "False";
+    PackingSchema[PackingSchema["True"] = 254] = "True";
+    PackingSchema[PackingSchema["Term"] = 255] = "Term";
+})(PackingSchema || (PackingSchema = {}));
 const SHV_EPOCH_MSEC = 1_517_529_600_000;
 const INVALID_MIN_OFFSET_FROM_UTC = (-64 * 15);
-
-const divInt = (n: bigint, d: bigint) => {
+const divInt = (n, d) => {
     const r = n % d;
-    return [(n - r) / d, r] as const;
+    return [(n - r) / d, r];
 };
-
-const uint8ArrayBoBigint = (bytes: Uint8Array, type: 'Int' | 'UInt') => {
+const uint8ArrayBoBigint = (bytes, type) => {
     let isNeg = false;
-
     if (type === 'Int') {
         if (bytes.length < 5) {
             const signMask = 0x80 >> bytes.length;
             isNeg = Boolean(bytes[0] & signMask);
             bytes[0] &= ~signMask;
-        } else {
+        }
+        else {
             isNeg = Boolean(bytes[1] & 128);
             bytes[1] &= ~128;
         }
     }
-
     let ret = 0n;
     for (const byte of bytes) {
         ret = (ret * BigInt(256)) + BigInt(byte);
     }
-
     if (isNeg) {
         ret = -ret;
     }
-
     return ret;
 };
-
-const numberToUint8Array = (num: bigint) => {
+const numberToUint8Array = (num) => {
     let bytes = new Uint8Array(8);
     let len = 0;
     do {
@@ -66,163 +62,130 @@ const numberToUint8Array = (num: bigint) => {
         num = res[0];
         bytes[len++] = Number(res[1]);
     } while (num !== 0n);
-
     bytes = bytes.subarray(0, len);
     bytes.reverse();
     return bytes;
 };
-
-const significantBitsCount = (num: bigint) => {
+const significantBitsCount = (num) => {
     let ret = 0;
     while (num > 0) {
         ret++;
         num >>= 1n;
     }
-
     return ret;
 };
-
 class ChainPackReader {
-    ctx: UnpackContext;
-
-    constructor(data: ArrayBuffer | UnpackContext) {
-        this.ctx = data instanceof UnpackContext ? data : new UnpackContext(data);
+    ctx;
+    constructor(data) {
+        this.ctx = data instanceof cpcontext_1.UnpackContext ? data : new cpcontext_1.UnpackContext(data);
     }
-
     /* eslint-disable complexity */
-    read(): RpcValue {
-        let meta: MetaMap | undefined;
-        let codePointAt = this.ctx.getByte() as PackingSchema;
-
+    read() {
+        let meta;
+        let codePointAt = this.ctx.getByte();
         if (codePointAt === PackingSchema.MetaMap) {
             meta = this.readMetaMap();
             codePointAt = this.ctx.getByte();
         }
-
-        const implReturn = (x: RpcValueType) => {
-            const ret = meta !== undefined ? new RpcValueWithMetaData(meta, x) : x;
+        const implReturn = (x) => {
+            const ret = meta !== undefined ? new rpcvalue_1.RpcValueWithMetaData(meta, x) : x;
             return ret;
         };
-
         if (codePointAt < PackingSchema.Null) {
             if (codePointAt >= PackingSchema.IntThreshold) {
                 return implReturn(codePointAt - 64);
             }
-
-            return implReturn(new UInt(codePointAt));
+            return implReturn(new rpcvalue_1.UInt(codePointAt));
         }
-
         switch (codePointAt) {
             case PackingSchema.Null: {
                 return implReturn(undefined);
             }
-
             case PackingSchema.True: {
                 return implReturn(true);
             }
-
             case PackingSchema.False: {
                 return implReturn(false);
             }
-
             case PackingSchema.Int: {
                 return implReturn(this.readIntData());
             }
-
             case PackingSchema.UInt: {
-                return implReturn(new UInt(this.readUIntData()));
+                return implReturn(new rpcvalue_1.UInt(this.readUIntData()));
             }
-
             case PackingSchema.Double: {
                 const data = new Uint8Array(8);
                 for (let i = 0; i < 8; i++) {
                     data[i] = this.ctx.getByte();
                 }
-
-                return implReturn(new Double(new DataView(data.buffer).getFloat64(0, true))); // little endian
+                return implReturn(new rpcvalue_1.Double(new DataView(data.buffer).getFloat64(0, true))); // little endian
             }
-
             case PackingSchema.Decimal: {
                 const mant = this.readIntData();
                 const exp = this.readIntData();
-                return implReturn(new Decimal(mant, exp));
+                return implReturn(new rpcvalue_1.Decimal(mant, exp));
             }
-
             case PackingSchema.DateTime: {
                 let bi = this.readUIntDataHelper('UInt');
                 const hasTzOffset = bi & 1n;
                 const hasNotMsec = bi & 2n;
                 bi >>= 2n;
-
                 let offset = 0;
                 if (hasTzOffset !== 0n) {
-                    offset = Number(bi & 0x7Fn);
+                    offset = Number(bi & 0x7fn);
                     if ((offset & 0x40) !== 0) {
                         // sign extension
                         offset -= 128;
                     }
-
                     bi >>= 7n;
                 }
-
                 offset *= 15;
-
                 if (offset === INVALID_MIN_OFFSET_FROM_UTC) {
                     return implReturn(undefined);
                 }
-
                 let msec = Number(bi);
                 if (hasNotMsec !== 0n) {
                     msec *= 1000;
                 }
-
                 msec += SHV_EPOCH_MSEC;
                 msec -= offset * 60_000;
-                return withOffset(new Date(msec), offset ?? undefined);
+                return (0, rpcvalue_1.withOffset)(new Date(msec), offset ?? undefined);
             }
-
             case PackingSchema.Map: {
                 return implReturn(this.readMap());
             }
-
             case PackingSchema.IMap: {
                 return implReturn(this.readIMap());
             }
-
             case PackingSchema.List: {
                 return implReturn(this.readList());
             }
-
             case PackingSchema.Blob: {
                 const strLen = this.readUIntData();
                 const arr = new Uint8Array(strLen);
                 for (let i = 0; i < strLen; i++) {
                     arr[i] = this.ctx.getByte();
                 }
-
                 return implReturn(arr.buffer);
             }
-
             case PackingSchema.String: {
                 const strLen = this.readUIntData();
                 const arr = new Uint8Array(strLen);
                 for (let i = 0; i < strLen; i++) {
                     arr[i] = this.ctx.getByte();
                 }
-
-                return implReturn(utf8ToString(arr.buffer));
+                return implReturn((0, cpon_1.utf8ToString)(arr.buffer));
             }
-
             case PackingSchema.CString: {
                 // variation of CponReader.readCString()
-                const pctx = new PackContext();
+                const pctx = new cpcontext_1.PackContext();
                 while (true) {
                     let b = this.ctx.getByte();
                     if (b === '\\'.codePointAt(0)) {
                         b = this.ctx.getByte();
                         switch (b) {
                             case '\\'.codePointAt(0):
-                                pctx.putByte('\\'.codePointAt(0)!);
+                                pctx.putByte('\\'.codePointAt(0));
                                 break;
                             case '0'.codePointAt(0):
                                 pctx.putByte(0);
@@ -231,24 +194,23 @@ class ChainPackReader {
                                 pctx.putByte(b);
                                 break;
                         }
-                    } else if (b === 0) {
+                    }
+                    else if (b === 0) {
                         // end of string
                         break;
-                    } else {
+                    }
+                    else {
                         pctx.putByte(b);
                     }
                 }
-
-                return implReturn(utf8ToString(pctx.buffer()));
+                return implReturn((0, cpon_1.utf8ToString)(pctx.buffer()));
             }
-
             default:
                 throw new TypeError('ChainPack - Invalid type info: ' + codePointAt);
         }
     }
     /* eslint-enable complexity */
-
-    readUIntDataHelper(type: 'Int' | 'UInt') {
+    readUIntDataHelper(type) {
         let num = 0;
         const head = this.ctx.getByte();
         let bytesToReadCnt;
@@ -258,135 +220,113 @@ class ChainPackReader {
                 num = head & 127;
                 break;
             }
-
             case head & 64: {
                 bytesToReadCnt = 1;
                 num = head & 63;
                 break;
             }
-
             case head & 32: {
                 bytesToReadCnt = 2;
                 num = head & 31;
                 break;
             }
-
             case head & 16: {
                 bytesToReadCnt = 3;
                 num = head & 15;
                 break;
             }
-
             default: {
                 bytesToReadCnt = (head & 0xF) + 4;
             }
         }
-
         const bytes = new Uint8Array(bytesToReadCnt + 1);
         bytes[0] = num;
         for (let i = 0; i < bytesToReadCnt; i++) {
             const r = this.ctx.getByte();
             bytes[i + 1] = r;
         }
-
         return uint8ArrayBoBigint(bytes, type);
     }
-
     readIntData() {
         const val = this.readUIntDataHelper('Int');
         if (val <= Number.MIN_SAFE_INTEGER) {
             return Number.MIN_SAFE_INTEGER;
         }
-
         if (val >= Number.MAX_SAFE_INTEGER) {
             return Number.MAX_SAFE_INTEGER;
         }
-
         return Number(val);
     }
-
     readUIntData() {
         const val = this.readUIntDataHelper('UInt');
         if (val >= Number.MAX_SAFE_INTEGER) {
             return Number.MAX_SAFE_INTEGER;
         }
-
         return Number(val);
     }
-
     readList() {
         const lst = [];
         while (true) {
             const b = this.ctx.peekByte();
-            if (b as PackingSchema === PackingSchema.Term) {
+            if (b === PackingSchema.Term) {
                 this.ctx.getByte();
                 break;
             }
-
             lst.push(this.read());
         }
-
         return lst;
     }
-
     readMetaMap() {
         return this.implReadMap('metamap');
     }
-
     readMap() {
         return this.implReadMap('map');
     }
-
     readIMap() {
         return this.implReadMap('imap');
     }
-
-    private implReadMap(mapType: 'map'): ShvMap;
-    private implReadMap(mapType: 'imap'): IMap;
-    private implReadMap(mapType: 'metamap'): MetaMap;
-    private implReadMap(mapType: 'map' | 'imap' | 'metamap') {
-        const map: ShvMap | IMap | MetaMap = {
-            [shvMapType]: mapType,
+    implReadMap(mapType) {
+        const map = {
+            [rpcvalue_1.shvMapType]: mapType,
         };
         while (true) {
             const b = this.ctx.peekByte();
-            if (b as PackingSchema === PackingSchema.Term) {
+            if (b === PackingSchema.Term) {
                 this.ctx.getByte();
                 break;
             }
-
             const key = this.read();
             const val = this.read();
-            if (map[shvMapType] === 'metamap' && typeof key === 'string') {
+            if (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'string') {
                 map[key] = val;
-            } else if (map[shvMapType] === 'metamap' && typeof key === 'number') {
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'metamap' && typeof key === 'number') {
                 map[Number(key)] = val;
-            } else if (map[shvMapType] === 'map' && typeof key === 'string') {
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'map' && typeof key === 'string') {
                 map[key] = val;
-            } else if (map[shvMapType] === 'imap' && typeof key === 'number') {
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'imap' && typeof key === 'number') {
                 map[Number(key)] = val;
-            } else {
+            }
+            else {
                 throw new TypeError('Malformed map, invalid key');
             }
         }
-
         return map;
     }
 }
-
+exports.ChainPackReader = ChainPackReader;
 class ChainPackWriter {
-    ctx: PackContext;
-
+    ctx;
     constructor() {
-        this.ctx = new PackContext();
+        this.ctx = new cpcontext_1.PackContext();
     }
-
-    write(rpcVal: RpcValue) {
-        if (rpcVal instanceof RpcValueWithMetaData) {
+    write(rpcVal) {
+        if (rpcVal instanceof rpcvalue_1.RpcValueWithMetaData) {
             this.writeMeta(rpcVal.meta);
             rpcVal = rpcVal.value;
         }
-
         switch (true) {
             case rpcVal === undefined:
                 this.ctx.putByte(PackingSchema.Null);
@@ -400,13 +340,13 @@ class ChainPackWriter {
             case rpcVal instanceof ArrayBuffer:
                 this.writeBlob(rpcVal);
                 break;
-            case rpcVal instanceof UInt:
+            case rpcVal instanceof rpcvalue_1.UInt:
                 this.writeUInt(rpcVal);
                 break;
             case typeof rpcVal === 'number':
                 this.writeInt(rpcVal);
                 break;
-            case rpcVal instanceof Decimal:
+            case rpcVal instanceof rpcvalue_1.Decimal:
                 this.writeDecimal(rpcVal);
                 break;
             case Array.isArray(rpcVal):
@@ -415,11 +355,11 @@ class ChainPackWriter {
             case rpcVal instanceof Date:
                 this.writeDateTime(rpcVal);
                 break;
-            case rpcVal instanceof Double:
+            case rpcVal instanceof rpcvalue_1.Double:
                 this.writeDouble(rpcVal);
                 break;
             case typeof rpcVal === 'object':
-                switch (rpcVal[shvMapType]) {
+                switch (rpcVal[rpcvalue_1.shvMapType]) {
                     case 'imap':
                         this.writeIMap(rpcVal);
                         break;
@@ -427,114 +367,95 @@ class ChainPackWriter {
                         this.writeMap(rpcVal);
                         break;
                 }
-
                 break;
             default:
                 console.log('Can\'t serialize', rpcVal);
                 throw new Error('Can\'t serialize');
         }
     }
-
-    writeUIntDataHelper(num: bigint, type: 'Int' | 'UInt') {
+    writeUIntDataHelper(num, type) {
         const isNegative = num < 0;
         if (isNegative) {
             num = -num;
         }
-
-        const significantBits = significantBitsCount(num) + (/* one more needed for sign bit */ type === 'Int' ? 1 : 0);
+        const significantBits = significantBitsCount(num) + ( /* one more needed for sign bit */type === 'Int' ? 1 : 0);
         const bytesNeeded = significantBits <= 28 ? Math.trunc((significantBits - 1) / 7) + 1 : Math.trunc((significantBits - 1) / 8) + 2;
-
         switch (bytesNeeded) {
             case 0:
                 throw new Error(`Failed to count bytes needed for ${num}`);
             case 1:
                 if (isNegative) {
-                    num |= 0b0100_0000n;
+                    num |= 64n;
                 }
-
                 break;
             case 2:
-                num |= 0b1000_0000n << 8n;
+                num |= 128n << 8n;
                 if (isNegative) {
-                    num |= 0b0010_0000n << 8n;
+                    num |= 32n << 8n;
                 }
-
                 break;
             case 3:
-                num |= 0b1100_0000n << 16n;
+                num |= 192n << 16n;
                 if (isNegative) {
-                    num |= 0b0001_0000n << 16n;
+                    num |= 16n << 16n;
                 }
-
                 break;
             case 4:
-                num |= 0b1110_0000n << 24n;
+                num |= 224n << 24n;
                 if (isNegative) {
-                    num |= 0b0000_1000n << 24n;
+                    num |= 8n << 24n;
                 }
-
                 break;
             default:
-                num |= 0b1111_0000n << BigInt((bytesNeeded - 1) * 8);
+                num |= 240n << BigInt((bytesNeeded - 1) * 8);
                 num |= BigInt(bytesNeeded - 4 /* n is offset by 4 */ - 1 /* for the control byte */) << BigInt((bytesNeeded - 1) * 8);
                 if (isNegative) {
-                    num |= 0b1000_0000n << BigInt((bytesNeeded - 2) * 8);
+                    num |= 128n << BigInt((bytesNeeded - 2) * 8);
                 }
-
                 break;
         }
-
         const bytes = numberToUint8Array(num);
         for (const byte of bytes) {
             this.ctx.putByte(byte);
         }
     }
-
-    writeUIntData(num: number) {
+    writeUIntData(num) {
         this.writeUIntDataHelper(BigInt(num), 'UInt');
     }
-
-    writeIntData(snum: number) {
+    writeIntData(snum) {
         this.writeUIntDataHelper(BigInt(snum), 'Int');
     }
-
-    writeInt(n: Int) {
+    writeInt(n) {
         if (Number(n) >= 0 && Number(n) < 64) {
             this.ctx.putByte(Number(n) + 64);
             return;
         }
-
         this.ctx.putByte(PackingSchema.Int);
         this.writeIntData(Number(n));
     }
-
-    writeUInt(n: UInt) {
+    writeUInt(n) {
         if (Number(n) < 64) {
             this.ctx.putByte(Number(n));
             return;
         }
-
         this.ctx.putByte(PackingSchema.UInt);
         this.writeUIntData(Number(n));
     }
-
-    writeJSString(str: string) {
+    writeJSString(str) {
         this.ctx.putByte(PackingSchema.String);
-        const pctx = new PackContext();
+        const pctx = new cpcontext_1.PackContext();
         pctx.writeStringUtf8(str);
         this.writeUIntData(pctx.length);
         for (let i = 0; i < pctx.length; i++) {
             this.ctx.putByte(pctx.data[i]);
         }
     }
-
-    writeDecimal(val: Decimal) {
+    writeDecimal(val) {
         this.ctx.putByte(PackingSchema.Decimal);
         this.writeIntData(val.mantisa);
         this.writeIntData(val.exponent);
     }
-
-    writeBlob(blob: ArrayBuffer) {
+    writeBlob(blob) {
         this.ctx.putByte(PackingSchema.Blob);
         const arr = new Uint8Array(blob);
         this.writeUIntData(arr.length);
@@ -542,119 +463,100 @@ class ChainPackWriter {
             this.ctx.putByte(element);
         }
     }
-
-    writeDateTime(dt: DateTime) {
+    writeDateTime(dt) {
         this.ctx.putByte(PackingSchema.DateTime);
-
         let msecs = (dt.getTime() + (60_000 * (dt.utc_offset ?? 0))) - SHV_EPOCH_MSEC;
         if (msecs < 0) {
             throw new RangeError('DateTime prior to 2018-02-02 are not supported in current ChainPack implementation.');
         }
-
         const ms = msecs % 1000;
         if (ms === 0) {
             msecs /= 1000;
         }
-
         let bi = BigInt(msecs);
         if (dt.utc_offset !== undefined && dt.utc_offset !== 0) {
             bi <<= 7n;
             bi |= BigInt((dt.utc_offset / 15) & 0x7F);
         }
-
         bi <<= 2n;
-
         if (dt.utc_offset !== undefined && dt.utc_offset !== 0) {
             bi |= 1n;
         }
-
         if (ms === 0) {
             bi |= 2n;
         }
-
         // save as signed int
         this.writeUIntDataHelper(bi, 'UInt');
     }
-
-    writeDouble(double: Double) {
+    writeDouble(double) {
         this.ctx.putByte(PackingSchema.Double);
         const buffer = new ArrayBuffer(8);
         const view = new DataView(buffer);
-
         view.setFloat64(0, double.value, true);
-
         const data = new Uint8Array(buffer);
         for (let i = 0; i < 8; i++) {
             this.ctx.putByte(data[i]);
         }
     }
-
-    writeList(lst: RpcValue[]) {
+    writeList(lst) {
         this.ctx.putByte(PackingSchema.List);
         for (const element of lst) {
             this.write(element);
         }
-
         this.ctx.putByte(PackingSchema.Term);
     }
-
-    writeMeta(map: MetaMap) {
+    writeMeta(map) {
         this.ctx.putByte(PackingSchema.MetaMap);
         this.writeMapContent(map);
     }
-
-    writeIMap(map: IMap) {
+    writeIMap(map) {
         this.ctx.putByte(PackingSchema.IMap);
         this.writeMapContent(map);
     }
-
-    writeMap(map: ShvMap) {
+    writeMap(map) {
         this.ctx.putByte(PackingSchema.Map);
         this.writeMapContent(map);
     }
-
-    writeMapContent(map: MetaMap | ShvMap | IMap) {
-        for (const [key, value] of Object.entries<RpcValue>(map)) {
+    writeMapContent(map) {
+        for (const [key, value] of Object.entries(map)) {
             if (value === undefined) {
                 continue;
             }
-
-            if (map[shvMapType] === 'imap') {
+            if (map[rpcvalue_1.shvMapType] === 'imap') {
                 const intKey = Number(key);
                 if (Number.isNaN(intKey)) {
                     throw new TypeError('Invalid NaN IMap key');
                 }
-
                 this.writeInt(intKey);
-            } else if (map[shvMapType] === 'metamap') {
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'metamap') {
                 const intKey = Number(key);
                 if (Number.isNaN(intKey)) {
                     this.writeJSString(key.toString());
-                } else {
+                }
+                else {
                     this.writeInt(intKey);
                 }
-            } else {
+            }
+            else {
                 this.writeJSString(key.toString());
             }
-
             this.write(value);
         }
-
         this.ctx.putByte(PackingSchema.Term);
     }
 }
-
-const toChainPack = (value: RpcValue) => {
+exports.ChainPackWriter = ChainPackWriter;
+const toChainPack = (value) => {
     const wr = new ChainPackWriter();
     wr.write(value);
     return wr.ctx.buffer();
 };
-
-const fromChainPack = (buffer: ArrayBuffer) => {
+exports.toChainPack = toChainPack;
+const fromChainPack = (buffer) => {
     const reader = new ChainPackReader(buffer);
     return reader.read();
 };
-
+exports.fromChainPack = fromChainPack;
 const CHAINPACK_PROTOCOL_TYPE = 1;
-
-export {toChainPack, fromChainPack, ChainPackReader, ChainPackWriter, CHAINPACK_PROTOCOL_TYPE};
+exports.CHAINPACK_PROTOCOL_TYPE = CHAINPACK_PROTOCOL_TYPE;