libshv-js 3.16.1 → 3.20.0

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

@@ -1,108 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromCpon = exports.toCpon = exports.CPON_PROTOCOL_TYPE = exports.CponReader = exports.CponWriter = exports.utf8ToString = exports.OneLiners = exports.stringifyDate = void 0;
 /* eslint-disable no-bitwise */
-import {type RpcValue, type RpcValueType, type DateTime, type List, Decimal, Double, type IMap, type Int, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, shvMapType, isShvMap, isIMap} from './rpcvalue';
-import {PackContext, UnpackContext} from './cpcontext';
-
-export const stringifyDate = (dt: DateTime) => {
+const rpcvalue_1 = require("./rpcvalue");
+const cpcontext_1 = require("./cpcontext");
+const stringifyDate = (dt) => {
     const epochMsec = dt.getTime();
     let utcOffset = dt.utc_offset;
     const localMsec = epochMsec + (60_000 * (utcOffset ?? 0));
     let res = new Date(localMsec).toISOString();
     const rtrim = ((localMsec % 1000) !== 0) ? 1 : 5;
     res = res.slice(0, Math.max(0, res.length - rtrim));
-
     if (utcOffset === undefined || utcOffset === 0) {
         res += 'Z';
-    } else {
+    }
+    else {
         if (utcOffset < 0) {
             res += '-';
             utcOffset = -utcOffset;
-        } else {
+        }
+        else {
             res += '+';
         }
-
         res += (Math.trunc(utcOffset / 60)).toString().padStart(2, '0');
         if ((utcOffset % 60) !== 0) {
             res += (utcOffset % 60).toString().padStart(2, '0');
         }
     }
-
     return res;
 };
-
-const hexify = (byte: number) => {
+exports.stringifyDate = stringifyDate;
+const hexify = (byte) => {
     if (byte < 10) {
         return 48 + byte;
     }
-
     if (byte < 16) {
         return 97 + byte - 10;
     }
-
-    return '?'.codePointAt(0)!;
+    return '?'.codePointAt(0);
 };
-
-const unhex = (byte: number) => {
+const unhex = (byte) => {
     if (byte >= 48 && byte <= 57) { // 0-9
         return byte - 48;
     }
-
     if (byte >= 65 && byte <= 70) { // A-F
         return byte - 65 + 10;
     }
-
     if (byte >= 97 && byte <= 102) { // a-f
         return byte - 97 + 10;
     }
-
     throw new TypeError('Invalid HEX digit: ' + byte);
 };
-
-const utf8ToString = (bytearray: ArrayBuffer) => {
+const utf8ToString = (bytearray) => {
     const uint8Array = new Uint8Array(bytearray);
     let str = '';
     for (let i = 0; i < uint8Array.length; i++) {
         const value = uint8Array[i];
-
         if (value < 0x80) {
             str += String.fromCodePoint(value);
-        } else if (value > 0xBF && value < 0xE0) {
+        }
+        else if (value > 0xBF && value < 0xE0) {
             str += String.fromCodePoint(((value & 0x1F) << 6) | (uint8Array[i + 1] & 0x3F));
             i += 1;
-        } else if (value > 0xDF && value < 0xF0) {
+        }
+        else if (value > 0xDF && value < 0xF0) {
             str += String.fromCodePoint(((value & 0x0F) << 12) | ((uint8Array[i + 1] & 0x3F) << 6) | (uint8Array[i + 2] & 0x3F));
             i += 2;
-        } else {
+        }
+        else {
             // surrogate pair
             const charCode = (((value & 0x07) << 18) | ((uint8Array[i + 1] & 0x3F) << 12) | ((uint8Array[i + 2] & 0x3F) << 6) | (uint8Array[i + 3] & 0x3F)) - 0x01_00_00;
-
             str += String.fromCodePoint((charCode >> 10) | 0xD8_00, (charCode & 0x03_FF) | 0xDC_00);
             i += 3;
         }
     }
-
     return str;
 };
-
+exports.utf8ToString = utf8ToString;
 class CponReader {
-    ctx: UnpackContext;
-
-    constructor(unpackContext: UnpackContext) {
+    ctx;
+    constructor(unpackContext) {
         this.ctx = unpackContext;
     }
-
-    read(): RpcValue {
-        let meta: MetaMap | undefined;
+    read() {
+        let meta;
         this.skipWhitespace();
         let b = this.ctx.peekByte();
         if (b === '<'.codePointAt(0)) {
             meta = this.readMetaMap();
         }
-
-        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;
         };
-
         this.skipWhitespace();
         b = this.ctx.peekByte();
         // console.log("CHAR:", b, String.fromCodePoint(b));
@@ -110,91 +100,74 @@ class CponReader {
         if ((b >= 48 && b <= 57) || b === 43 || b === 45) {
             return implReturn(this.readNumber());
         }
-
         if (b === '"'.codePointAt(0)) {
             return implReturn(this.readCString());
         }
-
         if (b === 'b'.codePointAt(0)) {
             this.ctx.getByte();
             b = this.ctx.peekByte();
             if (b === '"'.codePointAt(0)) {
                 return implReturn(this.readBlobEsc());
             }
-
             throw new TypeError('Invalid Blob prefix.');
         }
-
         if (b === 'x'.codePointAt(0)) {
             this.ctx.getByte();
             b = this.ctx.peekByte();
             if (b === '"'.codePointAt(0)) {
                 return implReturn(this.readBlobHex());
             }
-
             throw new TypeError('Invalid HEX Blob prefix.');
         }
-
         if (b === '['.codePointAt(0)) {
             return implReturn(this.readList());
         }
-
         if (b === '{'.codePointAt(0)) {
             return implReturn(this.readMap());
         }
-
         if (b === 'i'.codePointAt(0)) {
             this.ctx.getByte();
             b = this.ctx.peekByte();
             if (b === '{'.codePointAt(0)) {
                 return implReturn(this.readIMap());
             }
-
             throw new TypeError('Invalid IMap prefix.');
         }
-
         if (b === 'd'.codePointAt(0)) {
             this.ctx.getByte();
             b = this.ctx.peekByte();
             if (b === '"'.codePointAt(0)) {
                 return implReturn(this.readDateTime());
             }
-
             throw new TypeError('Invalid DateTime prefix.');
         }
-
         if (b === 't'.codePointAt(0)) {
             this.ctx.getBytes('true');
             return implReturn(true);
         }
-
         if (b === 'f'.codePointAt(0)) {
             this.ctx.getBytes('false');
             return implReturn(false);
         }
-
         if (b === 'n'.codePointAt(0)) {
             this.ctx.getBytes('null');
             return implReturn(undefined);
         }
-
         throw new TypeError('Malformed Cpon input.');
     }
-
     skipWhitespace() {
-        const SPACE = ' '.codePointAt(0)!;
-        const SLASH = '/'.codePointAt(0)!;
-        const STAR = '*'.codePointAt(0)!;
-        const LF = '\n'.codePointAt(0)!;
-        const KEY_DELIM = ':'.codePointAt(0)!;
-        const FIELD_DELIM = ','.codePointAt(0)!;
+        const SPACE = ' '.codePointAt(0);
+        const SLASH = '/'.codePointAt(0);
+        const STAR = '*'.codePointAt(0);
+        const LF = '\n'.codePointAt(0);
+        const KEY_DELIM = ':'.codePointAt(0);
+        const FIELD_DELIM = ','.codePointAt(0);
         /* eslint-disable max-depth */
         while (true) {
             let b = this.ctx.peekByte();
             if (b < 1) {
                 return;
             }
-
             if (b > SPACE) {
                 switch (b) {
                     case SLASH: {
@@ -211,7 +184,8 @@ class CponReader {
                                     }
                                 }
                             }
-                        } else if (b === SLASH) {
+                        }
+                        else if (b === SLASH) {
                             // to end of line comment entered;
                             while (true) {
                                 b = this.ctx.getByte();
@@ -219,33 +193,30 @@ class CponReader {
                                     break;
                                 }
                             }
-                        } else {
+                        }
+                        else {
                             throw new TypeError('Malformed comment');
                         }
-
                         break;
                     }
-
                     case KEY_DELIM: {
                         this.ctx.getByte();
                         continue;
                     }
-
                     case FIELD_DELIM: {
                         this.ctx.getByte();
                         continue;
                     }
-
                     default:
                         return;
                 }
-            } else {
+            }
+            else {
                 this.ctx.getByte();
             }
         }
         /* eslint-enable max-depth */
     }
-
     readDateTime() {
         this.ctx.getByte(); // eat '"'
         let b = this.ctx.peekByte();
@@ -254,17 +225,13 @@ class CponReader {
             this.ctx.getByte();
             throw new TypeError('Malformed empty date separator in DateTime');
         }
-
         const date = this.readDateTimeInner();
-
         b = this.ctx.getByte();
         if (b !== '"'.codePointAt(0)) {
             throw new TypeError('DateTime literal should be terminated by \'"\'.');
         }
-
         return date;
     }
-
     readDateTimeInner() {
         let year = 0;
         let month = 0;
@@ -274,55 +241,43 @@ class CponReader {
         let sec = 0;
         let msec = 0;
         let utcOffset = 0;
-
         year = Number(this.readInt());
-
         let b = this.ctx.getByte();
         if (b !== '-'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-
         month = Number(this.readInt());
-
         b = this.ctx.getByte();
         if (b !== '-'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-
         day = Number(this.readInt());
-
         b = this.ctx.getByte();
         if (b !== ' '.codePointAt(0) && b !== 'T'.codePointAt(0)) {
             throw new TypeError('Malformed date-time separator in DateTime');
         }
-
         hour = Number(this.readInt());
-
         b = this.ctx.getByte();
         if (b !== ':'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-
         min = Number(this.readInt());
-
         b = this.ctx.getByte();
         if (b !== ':'.codePointAt(0)) {
             throw new TypeError('Malformed year-month separator in DateTime');
         }
-
         sec = Number(this.readInt());
-
         b = this.ctx.peekByte();
         if (b === '.'.codePointAt(0)) {
             this.ctx.getByte();
             msec = Number(this.readInt());
         }
-
         b = this.ctx.peekByte();
         if (b === 'Z'.codePointAt(0)) {
             // zulu time
             this.ctx.getByte();
-        } else if (b === '+'.codePointAt(0) || b === '-'.codePointAt(0)) {
+        }
+        else if (b === '+'.codePointAt(0) || b === '-'.codePointAt(0)) {
             // UTC time offset
             this.ctx.getByte();
             const ix1 = this.ctx.index;
@@ -331,26 +286,23 @@ class CponReader {
             if (!(n === 2 || n === 4)) {
                 throw new TypeError('Malformed TS offset in DateTime.');
             }
-
             if (n === 2) {
                 utcOffset = 60 * val;
-            } else if (n === 4) {
+            }
+            else if (n === 4) {
                 utcOffset = (60 * (Math.trunc(val / 100))) + (val % 100);
             }
-
             if (b === '-'.codePointAt(0)) {
                 utcOffset = -utcOffset;
             }
         }
-
         // let epoch_sec = CponReader.timegm(year, month, mday, hour, min, sec);
         let epochMsec = Date.UTC(year, month - 1, day, hour, min, sec, msec);
         epochMsec -= utcOffset * 60_000;
-        return withOffset(new Date(epochMsec), utcOffset ?? undefined);
+        return (0, rpcvalue_1.withOffset)(new Date(epochMsec), utcOffset ?? undefined);
     }
-
     readCString() {
-        const pctx = new PackContext();
+        const pctx = new cpcontext_1.PackContext();
         this.ctx.getByte(); // eat '"'
         while (true) {
             let b = this.ctx.getByte();
@@ -358,25 +310,25 @@ class CponReader {
                 b = this.ctx.getByte();
                 switch (b) {
                     case '\\'.codePointAt(0):
-                        pctx.putByte('\\'.codePointAt(0)!);
+                        pctx.putByte('\\'.codePointAt(0));
                         break;
                     case '"'.codePointAt(0):
-                        pctx.putByte('"'.codePointAt(0)!);
+                        pctx.putByte('"'.codePointAt(0));
                         break;
                     case 'b'.codePointAt(0):
-                        pctx.putByte('\b'.codePointAt(0)!);
+                        pctx.putByte('\b'.codePointAt(0));
                         break;
                     case 'f'.codePointAt(0):
-                        pctx.putByte('\f'.codePointAt(0)!);
+                        pctx.putByte('\f'.codePointAt(0));
                         break;
                     case 'n'.codePointAt(0):
-                        pctx.putByte('\n'.codePointAt(0)!);
+                        pctx.putByte('\n'.codePointAt(0));
                         break;
                     case 'r'.codePointAt(0):
-                        pctx.putByte('\r'.codePointAt(0)!);
+                        pctx.putByte('\r'.codePointAt(0));
                         break;
                     case 't'.codePointAt(0):
-                        pctx.putByte('\t'.codePointAt(0)!);
+                        pctx.putByte('\t'.codePointAt(0));
                         break;
                     case '0'.codePointAt(0):
                         pctx.putByte(0);
@@ -385,19 +337,19 @@ class CponReader {
                         pctx.putByte(b);
                         break;
                 }
-            } else if (b === '"'.codePointAt(0)) {
+            }
+            else if (b === '"'.codePointAt(0)) {
                 // end of string
                 break;
-            } else {
+            }
+            else {
                 pctx.putByte(b);
             }
         }
-
         return utf8ToString(pctx.buffer());
     }
-
     readBlobEsc() {
-        const pctx = new PackContext();
+        const pctx = new cpcontext_1.PackContext();
         this.ctx.getByte(); // eat '"'
         while (true) {
             let b = this.ctx.getByte();
@@ -405,19 +357,19 @@ class CponReader {
                 b = this.ctx.getByte();
                 switch (b) {
                     case '\\'.codePointAt(0):
-                        pctx.putByte('\\'.codePointAt(0)!);
+                        pctx.putByte('\\'.codePointAt(0));
                         break;
                     case '"'.codePointAt(0):
-                        pctx.putByte('"'.codePointAt(0)!);
+                        pctx.putByte('"'.codePointAt(0));
                         break;
                     case 'n'.codePointAt(0):
-                        pctx.putByte('\n'.codePointAt(0)!);
+                        pctx.putByte('\n'.codePointAt(0));
                         break;
                     case 'r'.codePointAt(0):
-                        pctx.putByte('\r'.codePointAt(0)!);
+                        pctx.putByte('\r'.codePointAt(0));
                         break;
                     case 't'.codePointAt(0):
-                        pctx.putByte('\t'.codePointAt(0)!);
+                        pctx.putByte('\t'.codePointAt(0));
                         break;
                     default: {
                         const b2 = (unhex(b) * 16) + unhex(this.ctx.getByte());
@@ -425,36 +377,36 @@ class CponReader {
                         break;
                     }
                 }
-            } else if (b === '"'.codePointAt(0)) {
+            }
+            else if (b === '"'.codePointAt(0)) {
                 // end of string
                 break;
-            } else if (b < 128) {
+            }
+            else if (b < 128) {
                 pctx.putByte(b);
-            } else {
+            }
+            else {
                 throw new TypeError('Escaped Blob characters must be lower than 128, code: ' + b);
             }
         }
-
         return pctx.buffer();
     }
-
     readBlobHex() {
-        const pctx = new PackContext();
+        const pctx = new cpcontext_1.PackContext();
         this.ctx.getByte(); // eat '"'
         while (true) {
             const b = this.ctx.getByte();
             if (b === '"'.codePointAt(0)) {
                 // end of string
                 break;
-            } else {
+            }
+            else {
                 const b2 = (unhex(b) * 16) + unhex(this.ctx.getByte());
                 pctx.putByte(b2);
             }
         }
-
         return pctx.buffer();
     }
-
     readList() {
         const lst = [];
         this.ctx.getByte(); // eat '['
@@ -465,89 +417,79 @@ class CponReader {
                 this.ctx.getByte();
                 break;
             }
-
             const item = this.read();
             lst.push(item);
         }
-
         return lst;
     }
-
     readMetaMap() {
-        return this.implReadMap('metamap', '>'.codePointAt(0)!);
+        return this.implReadMap('metamap', '>'.codePointAt(0));
     }
-
     readMap() {
-        return this.implReadMap('map', '}'.codePointAt(0)!);
+        return this.implReadMap('map', '}'.codePointAt(0));
     }
-
     readIMap() {
-        return this.implReadMap('imap', '}'.codePointAt(0)!);
+        return this.implReadMap('imap', '}'.codePointAt(0));
     }
-
     readInt() {
         let base = 10;
         let val = 0;
         let neg = false;
         let n = 0;
-        for (; ; n++) {
+        for (;; n++) {
             const b = this.ctx.peekByte();
             if (b < 0) {
                 break;
             }
-
             if (b === 43 || b === 45) { // '+','-'
                 if (n !== 0) {
                     break;
                 }
-
                 this.ctx.getByte();
                 if (b === 45) {
                     neg = true;
                 }
-            } else if (b === 120) { // 'x'
+            }
+            else if (b === 120) { // 'x'
                 if (n === 1 && val !== 0) {
                     break;
                 }
-
                 if (n !== 1) {
                     break;
                 }
-
                 this.ctx.getByte();
                 base = 16;
-            } else if (b >= 48 && b <= 57) { // '0' - '9'
+            }
+            else if (b >= 48 && b <= 57) { // '0' - '9'
                 this.ctx.getByte();
                 val *= base;
                 val += b - 48;
-            } else if (b >= 65 && b <= 70) { // 'A' - 'F'
+            }
+            else if (b >= 65 && b <= 70) { // 'A' - 'F'
                 if (base !== 16) {
                     break;
                 }
-
                 this.ctx.getByte();
                 val *= base;
                 val += b - 65 + 10;
-            } else if (b >= 97 && b <= 102) { // 'a' - 'f'
+            }
+            else if (b >= 97 && b <= 102) { // 'a' - 'f'
                 if (base !== 16) {
                     break;
                 }
-
                 this.ctx.getByte();
                 val *= base;
                 val += b - 97 + 10;
-            } else {
+            }
+            else {
                 break;
             }
         }
-
         if (neg) {
             val = -val;
         }
-
         return val;
     }
-
     readNumber() {
         let mantisa = 0;
         let exponent = 0;
@@ -556,16 +498,15 @@ class CponReader {
         let isDecimal = false;
         let isUint = false;
         let isNeg = false;
-
         let b = this.ctx.peekByte();
-        if (b === 43) {// '+'
+        if (b === 43) { // '+'
             isNeg = false;
             b = this.ctx.getByte();
-        } else if (b === 45) {// '-'
+        }
+        else if (b === 45) { // '-'
             isNeg = true;
             b = this.ctx.getByte();
         }
-
         mantisa = Number(this.readInt());
         b = this.ctx.peekByte();
         (() => {
@@ -576,7 +517,6 @@ class CponReader {
                         this.ctx.getByte();
                         return;
                     }
-
                     case '.'.codePointAt(0): {
                         isDecimal = true;
                         this.ctx.getByte();
@@ -589,10 +529,8 @@ class CponReader {
                         if (b >= 0) {
                             continue;
                         }
-
                         return;
                     }
-
                     case 'e'.codePointAt(0):
                     case 'E'.codePointAt(0): {
                         isDecimal = true;
@@ -602,39 +540,29 @@ class CponReader {
                         if (ix1 === this.ctx.index) {
                             throw new TypeError('Malformed number exponential part.');
                         }
-
                         return;
                     }
-
                     default:
                         return;
                 }
             }
         })();
-
         if (isDecimal) {
             for (let i = 0; i < decCnt; ++i) {
                 mantisa *= 10;
             }
-
             mantisa += decimals;
             mantisa = isNeg ? -mantisa : mantisa;
-            return new Decimal(mantisa, exponent - decCnt);
+            return new rpcvalue_1.Decimal(mantisa, exponent - decCnt);
         }
-
         if (isUint) {
-            return new UInt(mantisa);
+            return new rpcvalue_1.UInt(mantisa);
         }
-
         return isNeg ? -mantisa : mantisa;
     }
-
-    private implReadMap(mapType: 'map', terminator: number): ShvMap;
-    private implReadMap(mapType: 'imap', terminator: number): IMap;
-    private implReadMap(mapType: 'metamap', terminator: number): MetaMap;
-    private implReadMap(mapType: 'map' | 'imap' | 'metamap', terminator: number) {
-        const map: MetaMap | ShvMap | IMap = {
-            [shvMapType]: mapType,
+    implReadMap(mapType, terminator) {
+        const map = {
+            [rpcvalue_1.shvMapType]: mapType,
         };
         this.ctx.getByte(); // eat start
         while (true) {
@@ -644,46 +572,47 @@ class CponReader {
                 this.ctx.getByte();
                 break;
             }
-
             const key = this.read();
-            if (key instanceof RpcValueWithMetaData) {
+            if (key instanceof rpcvalue_1.RpcValueWithMetaData) {
                 throw new TypeError('Map/IMap/MetaMap key can\'t have its own MetaData');
             }
-
             this.skipWhitespace();
             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' && (key instanceof UInt || typeof key === 'number')) {
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'metamap' && (key instanceof rpcvalue_1.UInt || 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' && (key instanceof UInt || typeof key === 'number')) {
+            }
+            else if (map[rpcvalue_1.shvMapType] === 'imap' && (key instanceof rpcvalue_1.UInt || typeof key === 'number')) {
                 map[Number(key)] = val;
-            } else {
+            }
+            else {
                 throw new TypeError('Malformed map, invalid key');
             }
         }
-
         return map;
     }
 }
-
+exports.CponReader = CponReader;
 class CponWriter {
-    ctx: PackContext;
+    indentString;
+    oneLiners;
+    ctx;
     nestLevel = 0;
-
-    constructor(private readonly indentString?: string, private oneLiners: OneLiners = OneLiners.Yes) {
-        this.ctx = new PackContext();
+    constructor(indentString, oneLiners = OneLiners.Yes) {
+        this.indentString = indentString;
+        this.oneLiners = oneLiners;
+        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.writeStringUtf8('null');
@@ -697,16 +626,16 @@ class CponWriter {
             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 Double:
+            case rpcVal instanceof rpcvalue_1.Double:
                 this.writeDouble(rpcVal);
                 break;
-            case rpcVal instanceof Decimal:
+            case rpcVal instanceof rpcvalue_1.Decimal:
                 this.writeDecimal(rpcVal);
                 break;
             case Array.isArray(rpcVal):
@@ -716,7 +645,7 @@ class CponWriter {
                 this.writeDateTime(rpcVal);
                 break;
             case typeof rpcVal === 'object':
-                switch (rpcVal[shvMapType]) {
+                switch (rpcVal[rpcvalue_1.shvMapType]) {
                     case 'imap':
                         this.writeIMap(rpcVal);
                         break;
@@ -724,49 +653,45 @@ class CponWriter {
                         this.writeMap(rpcVal);
                         break;
                 }
-
                 break;
             default:
                 console.log('Can\'t serialize rpc value', rpcVal);
                 throw new Error('Can\'t serialize rpc value');
         }
     }
-
-    writeJSString(str: string) {
+    writeJSString(str) {
         this.ctx.writeStringUtf8('"');
         for (let i = 0; i < str.length; i++) {
-            const charcode = str.codePointAt(i)!;
+            const charcode = str.codePointAt(i);
             switch (charcode) {
                 case 0:
-                    this.ctx.writeStringUtf8(String.raw`\0`);
+                    this.ctx.writeStringUtf8(String.raw `\0`);
                     break;
                 case '\\'.codePointAt(0):
                     this.ctx.writeStringUtf8('\\\\');
                     break;
                 case '\t'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\t`);
+                    this.ctx.writeStringUtf8(String.raw `\t`);
                     break;
                 case '\b'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\b`);
+                    this.ctx.writeStringUtf8(String.raw `\b`);
                     break;
                 case '\r'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\r`);
+                    this.ctx.writeStringUtf8(String.raw `\r`);
                     break;
                 case '\n'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\n`);
+                    this.ctx.writeStringUtf8(String.raw `\n`);
                     break;
                 case '"'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\"`);
+                    this.ctx.writeStringUtf8(String.raw `\"`);
                     break;
                 default:
                     this.ctx.writeCharCodeUtf8(charcode);
             }
         }
-
         this.ctx.writeStringUtf8('"');
     }
-
-    writeBlob(buffer: ArrayBuffer) {
+    writeBlob(buffer) {
         this.ctx.writeStringUtf8('b"');
         const data = new Uint8Array(buffer);
         for (const b of data) {
@@ -775,226 +700,201 @@ class CponWriter {
                     this.ctx.writeStringUtf8('\\\\');
                     break;
                 case '\t'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\t`);
+                    this.ctx.writeStringUtf8(String.raw `\t`);
                     break;
                 case '\r'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\r`);
+                    this.ctx.writeStringUtf8(String.raw `\r`);
                     break;
                 case '\n'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\n`);
+                    this.ctx.writeStringUtf8(String.raw `\n`);
                     break;
                 case '"'.codePointAt(0):
-                    this.ctx.writeStringUtf8(String.raw`\"`);
+                    this.ctx.writeStringUtf8(String.raw `\"`);
                     break;
                 default:
                     if (b >= 32 && b < 127) {
                         this.ctx.putByte(b);
-                    } else {
-                        this.ctx.putByte('\\'.codePointAt(0)!);
+                    }
+                    else {
+                        this.ctx.putByte('\\'.codePointAt(0));
                         this.ctx.putByte(hexify(b / 16));
                         this.ctx.putByte(hexify(b % 16));
                     }
             }
         }
-
         this.ctx.writeStringUtf8('"');
     }
-
-    writeDateTime(dt: DateTime) {
+    writeDateTime(dt) {
         this.ctx.writeStringUtf8('d"');
-        this.ctx.writeStringUtf8(stringifyDate(dt));
+        this.ctx.writeStringUtf8((0, exports.stringifyDate)(dt));
         this.ctx.writeStringUtf8('"');
     }
-
-    writeBool(b: boolean) {
+    writeBool(b) {
         this.ctx.writeStringUtf8(b ? 'true' : 'false');
     }
-
-    writeMeta(map: MetaMap) {
+    writeMeta(map) {
         this.writeMapContent(map, '<', '>');
     }
-
-    writeIMap(map: IMap) {
+    writeIMap(map) {
         this.writeMapContent(map, 'i{', '}');
     }
-
-    writeMap(map: ShvMap) {
+    writeMap(map) {
         this.writeMapContent(map, '{', '}');
     }
-
-    writeMapContent(map: MetaMap | ShvMap | IMap, delimiterStart: string, delimiterEnd: string) {
+    writeMapContent(map, delimiterStart, delimiterEnd) {
         this.ctx.writeStringUtf8(delimiterStart);
         this.increaseIndentIfNotOneLiner(map);
         this.doIndentIfNotOneliner(map);
         let first = true;
-        for (const [key, value] of Object.entries<RpcValue>(map)) {
+        for (const [key, value] of Object.entries(map)) {
             if (!first) {
-                this.ctx.putByte(','.codePointAt(0)!);
+                this.ctx.putByte(','.codePointAt(0));
                 this.doIndentIfNotOneliner(map);
             }
-
             first = false;
-
-            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.ctx.putByte('"'.codePointAt(0)!);
+                    this.ctx.putByte('"'.codePointAt(0));
                     this.ctx.writeStringUtf8(key.toString());
-                    this.ctx.putByte('"'.codePointAt(0)!);
-                } else {
+                    this.ctx.putByte('"'.codePointAt(0));
+                }
+                else {
                     this.writeInt(intKey);
                 }
-            } else {
+            }
+            else {
                 this.writeJSString(key.toString());
             }
-
             this.ctx.writeStringUtf8(':');
             this.write(value);
         }
-
         this.decreaseIndentIfNotOneLiner(map);
         this.doIndentIfNotOneliner(map);
         this.ctx.writeStringUtf8(delimiterEnd);
     }
-
-    writeList(lst: RpcValue[]) {
-        this.ctx.putByte('['.codePointAt(0)!);
+    writeList(lst) {
+        this.ctx.putByte('['.codePointAt(0));
         this.increaseIndentIfNotOneLiner(lst);
         this.doIndentIfNotOneliner(lst);
         for (const [i, element] of lst.entries()) {
             if (i > 0) {
-                this.ctx.putByte(','.codePointAt(0)!);
+                this.ctx.putByte(','.codePointAt(0));
                 this.doIndentIfNotOneliner(lst);
             }
-
             this.write(element);
         }
-
         this.decreaseIndentIfNotOneLiner(lst);
         this.doIndentIfNotOneliner(lst);
-        this.ctx.putByte(']'.codePointAt(0)!);
+        this.ctx.putByte(']'.codePointAt(0));
     }
-
-    writeUInt(num: UInt) {
+    writeUInt(num) {
         const s = Number(num).toString();
         this.ctx.writeStringUtf8(s);
-        this.ctx.putByte('u'.codePointAt(0)!);
+        this.ctx.putByte('u'.codePointAt(0));
     }
-
-    writeInt(num: Int) {
+    writeInt(num) {
         const s = Number(num).toString();
         this.ctx.writeStringUtf8(s);
     }
-
-    writeDouble(num: Double) {
+    writeDouble(num) {
         let s = num.value.toString();
         if (!s.includes('.')) {
             s += '.';
         }
-
         this.ctx.writeStringUtf8(s);
     }
-
-    writeDecimal(val: Decimal) {
-        let {mantisa} = val;
-        const {exponent} = val;
+    writeDecimal(val) {
+        let { mantisa } = val;
+        const { exponent } = val;
         if (mantisa < 0) {
             mantisa = -mantisa;
-            this.ctx.putByte('-'.codePointAt(0)!);
+            this.ctx.putByte('-'.codePointAt(0));
         }
-
         let str = mantisa.toString();
         const n = str.length;
         const decPlaces = -exponent;
         if (decPlaces > 0 && decPlaces < n) {
             const dotIx = n - decPlaces;
             str = str.slice(0, dotIx) + '.' + str.slice(dotIx);
-        } else if (decPlaces > 0 && decPlaces <= 3) {
+        }
+        else if (decPlaces > 0 && decPlaces <= 3) {
             const extraZeroCnt = decPlaces - n;
             let str0 = '0.';
             for (let i = 0; i < extraZeroCnt; ++i) {
                 str0 += '0';
             }
-
             str = str0 + str;
-        } else if (decPlaces < 0 && n + exponent <= 9) {
+        }
+        else if (decPlaces < 0 && n + exponent <= 9) {
             for (let i = 0; i < exponent; ++i) {
                 str += '0';
             }
-
             str += '.';
-        } else if (decPlaces === 0) {
+        }
+        else if (decPlaces === 0) {
             str += '.';
-        } else {
+        }
+        else {
             str += 'e' + exponent;
         }
-
         for (let i = 0; i < str.length; ++i) {
-            this.ctx.putByte(str.codePointAt(i)!);
+            this.ctx.putByte(str.codePointAt(i));
         }
     }
-
-    private doIndentIfNotOneliner(map: MetaMap | ShvMap | IMap | List) {
+    doIndentIfNotOneliner(map) {
         if (this.indentString !== undefined && !this.isOneLiner(map)) {
-            this.ctx.putByte('\n'.codePointAt(0)!);
+            this.ctx.putByte('\n'.codePointAt(0));
             this.ctx.writeStringUtf8(this.indentString.repeat(this.nestLevel));
         }
     }
-
-    private isOneLiner(value: MetaMap | ShvMap | IMap | List) {
+    isOneLiner(value) {
         if (this.oneLiners === OneLiners.No) {
             return false;
         }
-
         const keyThreshold = Array.isArray(value) ? 10 : 5;
-
         if (Array.isArray(value)) {
-            return value.length <= keyThreshold && !(value.some(x => Array.isArray(x) || isShvMap(x) || isIMap(x)));
+            return value.length <= keyThreshold && !(value.some(x => Array.isArray(x) || (0, rpcvalue_1.isShvMap)(x) || (0, rpcvalue_1.isIMap)(x)));
         }
-
-        return Object.keys(value).length <= keyThreshold && !(Object.values(value).some(x => Array.isArray(x) || isShvMap(x) || isIMap(x)));
+        return Object.keys(value).length <= keyThreshold && !(Object.values(value).some(x => Array.isArray(x) || (0, rpcvalue_1.isShvMap)(x) || (0, rpcvalue_1.isIMap)(x)));
     }
-
-    private increaseIndentIfNotOneLiner(value: MetaMap | ShvMap | IMap | List) {
+    increaseIndentIfNotOneLiner(value) {
         if (!this.isOneLiner(value)) {
             this.nestLevel++;
         }
     }
-
-    private decreaseIndentIfNotOneLiner(value: MetaMap | ShvMap | IMap | List) {
+    decreaseIndentIfNotOneLiner(value) {
         if (!this.isOneLiner(value)) {
             this.nestLevel--;
         }
     }
 }
-
-export enum OneLiners {
-    Yes,
-    No,
-}
-
-const toCpon = (value: RpcValue, indentString?: string, oneLiners: OneLiners = OneLiners.Yes) => {
+exports.CponWriter = CponWriter;
+var OneLiners;
+(function (OneLiners) {
+    OneLiners[OneLiners["Yes"] = 0] = "Yes";
+    OneLiners[OneLiners["No"] = 1] = "No";
+})(OneLiners || (exports.OneLiners = OneLiners = {}));
+const toCpon = (value, indentString, oneLiners = OneLiners.Yes) => {
     const wr = new CponWriter(indentString, oneLiners);
     wr.write(value);
     return new TextDecoder().decode(wr.ctx.buffer());
 };
-
-const fromCpon = (str: string | Uint8Array) => {
+exports.toCpon = toCpon;
+const fromCpon = (str) => {
     if (typeof str === 'string') {
         str = new TextEncoder().encode(str);
     }
-
-    const rd = new CponReader(new UnpackContext(str.buffer));
+    const rd = new CponReader(new cpcontext_1.UnpackContext(str.buffer));
     return rd.read();
 };
-
+exports.fromCpon = fromCpon;
 const CPON_PROTOCOL_TYPE = 2;
-
-export {utf8ToString, CponWriter, CponReader, CPON_PROTOCOL_TYPE, toCpon, fromCpon};
+exports.CPON_PROTOCOL_TYPE = CPON_PROTOCOL_TYPE;