0.3.1

Author: username0101010

README.md

@@ -4,9 +4,10 @@
 [![codecov](https://codecov.io/gh/username0101010/array-buffer-serializer/branch/main/graph/badge.svg?token=IZFQQP34H7)](https://codecov.io/gh/username0101010/array-buffer-serializer)
 
 Allows to encode an object into bytes before transmission via WebRTC or WebSocket and decode it back when received. 
+This is very useful for network bandwidth when you need to send data to one or more recipients frequently.
 
-Some characters of the [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)), which is part of 
-[Unicode](https://en.wikipedia.org/wiki/Unicode), are reserved for encoding values: C0 (U+00C0) - E3 (U+00E3).
+Some characters of the [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block))
+are reserved for encoding values: C0 (U+00C0) - E3 (U+00E7).
 
 ## Installation
 
@@ -45,7 +46,7 @@ yarn add array-buffer-serializer
     ```
 
 3. **Send the buffer (for example, over WebScoket)**     
-    
+    frequently
     ```javascript
     ws.send(buffer);
     ```
@@ -80,7 +81,7 @@ Type | Economy (bytes)
 * Uses type definition instead of object's key-value separator ":" and array items delimiter ",";
 * Uses unsigned data representation by default (uint8_t, uint16_t...);
 * Different marks for positive and negative numbers, so negative sign is for free;
-* Marks are divided into even and odd, each odd mark indicates at the first array value, which saves at least 1 byte.
+* Marks are divided into even and odd, each odd mark indicates at the first array value.
 
 ## License
 

example/object.js

@@ -36,11 +36,8 @@ const data = {
     }
 };
 
-// NOTE: JSON.stringify() can't convert bigint
-// just to show length of all data, it was converted to a string
-const temp = { ...data };
-temp.bigint = data.bigint.toString();
-console.log("Original length:", JSON.stringify(temp).length - 1); // 451 
+BigInt.prototype.toJSON = function() { return this.toString() };
+console.log("Original length:", JSON.stringify(data).length - 1); // 451 
 
 const buffer = Serializer.toBuffer(data);
 console.log("Encoded length:", buffer.byteLength); // 249

lib/BufferDecoder.js

@@ -40,7 +40,7 @@ BufferDecoder.prototype.decode = function() {
         return;
     }
 
-    else if (0x00C0 <= code && code <= 0x00DF) {
+    else if (0x00C0 <= code && code <= 0x00E3) {
         this._parseValue(code - (code % 2 === 1 ? 1 : 0));
 
         // parse value as 1st array element
@@ -127,11 +127,19 @@ BufferDecoder.prototype._parseValue = function(code) {
 
     // -uint64_t
     else if (code === marks.DEFAULT_MARK_INT64)
-        this._value = -(this._fromInt64());
+        this._value = -(Number(this._fromInt64()));
 
     // uint64_t
     else if (code === marks.DEFAULT_MARK_UINT64)
-        this._value = this._fromInt64(); 
+        this._value = Number(this._fromInt64()); 
+
+    // -bigint
+    else if (code === marks.DEFAULT_MARK_BIGINT)
+        this._value = -(this._fromInt64());
+
+    // bigint
+    else if (code === marks.DEFAULT_MARK_UBIGINT) 
+        this._value = this._fromInt64();
 
     // float
     else if (code === marks.DEFAULT_MARK_FLOAT)

lib/BufferEncoder.js

@@ -71,7 +71,7 @@ BufferEncoder.prototype.encode = function(key, val, index) {
             this._setMark(marks.DEFAULT_MARK_UNDEF, index); 
             break;
         case "bigint":
-            this._setMark(val < 0 ? marks.DEFAULT_MARK_INT64 : marks.DEFAULT_MARK_UINT64, index);
+            this._setMark(val < 0 ? marks.DEFAULT_MARK_BIGINT : marks.DEFAULT_MARK_UBIGINT, index);
             this._toInt64(val < 0 ? -val : val);
             break;
         case "number":
@@ -149,6 +149,12 @@ BufferEncoder.prototype._asInteger = function(val, index) {
         this._setMark(val < 0 ? marks.DEFAULT_MARK_INT32 : marks.DEFAULT_MARK_UINT32, index);
         this._toInt32(absVal);
     }
+
+    // uint64_t
+    else if (absVal <= 18446744073709552000) {
+        this._setMark(val < 0 ? marks.DEFAULT_MARK_INT64 : marks.DEFAULT_MARK_UINT64, index);
+        this._toInt64(val < 0 ? BigInt(-val) : BigInt(val));
+    }
 };
 
 /** 

lib/marks.js

@@ -113,34 +113,50 @@ module.exports = {
      * @default
      */
     DEFAULT_MARK_OBJ_OPEN: 0x00DE,
+    /**
+     * Mark for unsigned bigint.
+     *
+     * @example 25n
+     * @constant
+     * @default
+     */
+    DEFAULT_MARK_UBIGINT: 0x00E0,
+    /**
+     * Mark for signed bigint.
+     *
+     * @example -25n
+     * @constant
+     * @default
+     */
+    DEFAULT_MARK_BIGINT: 0x00E2,
     /**
      * Mark for close object value.
      *
      * @example }
      * @constant
      * @default
      */
-    DEFAULT_MARK_OBJ_CLOSE: 0x00E0,
+    DEFAULT_MARK_OBJ_CLOSE: 0x00E4,
     /**
      * Mark for close array value.
      *
      * @example ]
      * @constant
      * @default
      */
-    DEFAULT_MARK_ARR_CLOSE: 0x00E1,
+    DEFAULT_MARK_ARR_CLOSE: 0x00E5,
     /** Mark for open array value.
      *
      * @example [
      * @constant
      * @default
      */
-    DEFAULT_MARK_ARR_OPEN: 0x00E2,
+    DEFAULT_MARK_ARR_OPEN: 0x00E6,
     /** Mark for empty array value.
      *
      * @example []
      * @constant
      * @default
      */
-    DEFAULT_MARK_ARR_EMPTY: 0x00E3
+    DEFAULT_MARK_ARR_EMPTY: 0x00E7
 };

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "array-buffer-serializer",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Serializes data to transfer fewer bytes over the network",
   "main": "index.js",
   "types": "index.d.ts",

package.json

@@ -16,16 +16,16 @@ describe("BufferDecoder", () => {
     const setNegAndPosIntAtOnce = exp => {
         let offset = exp / 8;
         let method = exp < 64 ? `setUint${exp}` : `setBigUint${exp}`;
-        let number = exp < 64 ? Math.pow(2, exp) - 1 : 2n ** 64n - 1n; 
+        let number = exp < 64 ? Math.pow(2, exp) - 1 :  BigInt(Math.pow(2, 42)); 
 
         // set positive
         dv.setUint8(1, marks[`DEFAULT_MARK_UINT${exp}`]);
         dv[method](2, number);
         // set negative
         dv.setUint8(2 + offset, marks[`DEFAULT_MARK_INT${exp}`]);
         dv[method](3 + offset, number);
-        decodeAndExpect(1 + offset, number, 0, [0]);
-        decodeAndExpect((1 + offset) * 2, -number, 1, [1]);
+        decodeAndExpect(1 + offset, exp < 64 ? number : Number(number), 0, [0]);
+        decodeAndExpect((1 + offset) * 2, exp < 64 ? -number : -(Number(number)), 1, [1]);
     };
 
     beforeEach(() => {
@@ -65,6 +65,18 @@ describe("BufferDecoder", () => {
         decodeAndExpect(9, 1.23456789012, 0);
     });
 
+    it("decodes bigint correctly", () => {
+        dv.setUint8(1, marks.DEFAULT_MARK_BIGINT);
+        dv.setBigUint64(2, 2n);
+        decodeAndExpect(9, -2n, 0);
+    });
+
+    it("decodes ubigint correctly", () => {
+        dv.setUint8(1, marks.DEFAULT_MARK_UBIGINT);
+        dv.setBigUint64(2, 2n);
+        decodeAndExpect(9, 2n, 0);
+    });
+
     it("decodes boolean (both: true and false) correctly", () => {
         dv.setUint8(1, marks.DEFAULT_MARK_FBOOL);
         dv.setUint8(2, marks.DEFAULT_MARK_TBOOL);

test/BufferDecoder.test.js

@@ -22,7 +22,7 @@ describe("BufferEncoder", () => {
         expect(bufferEncoder._bytes).toBe(4);
     });
 
-    it("encodes to uint64 correctly", () => {
+    it("encodes to ubigint correctly", () => {
         bufferEncoder._toInt64(2n ** 64n - 1n);
         expect(bufferEncoder._bytes).toBe(8);
     });
@@ -102,12 +102,18 @@ describe("BufferEncoder", () => {
         expect(bufferEncoder._bytes).toBe(10);
     });
 
-    it("encodes 2^64 and -2^64 as 18 bytes (with marks)", () => {
+    it("encodes 2^64 and -2^64 (bigint) as 18 bytes (with marks)", () => {
         bufferEncoder.encode(undefined, 2n ** 64n - 1n);
         bufferEncoder.encode(undefined, -(2n ** 64n - 1n));
         expect(bufferEncoder._bytes).toBe(18);
     });
 
+    it("encodes 2^64 and -2^64 (integer) as 18 bytes (with marks)", () => {
+        bufferEncoder.encode(undefined, 2 ** 64 - 1);
+        bufferEncoder.encode(undefined, -(2 ** 64 - 1));
+        expect(bufferEncoder._bytes).toBe(18);
+    });
+
     it("encodes 1.234567 as 5 bytes (float with mark)", () => {
         bufferEncoder.encode(undefined, 1.234567);
         expect(bufferEncoder._bytes).toBe(5);