bin-serde 1.4.1 → 1.5.0

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": false,
+  "printWidth": 120,
+  "tabWidth": 2,
+  "useTabs": false,
+  "arrowParens": "always"
+}

package/index.ts

@@ -3,184 +3,197 @@ import utf8Size from "utf8-buffer-size";
 
 export class Writer {
   private pos = 0;
-  private view: DataView;
   private bytes: Uint8Array;
+  private _view: DataView | null = null;
 
-  public constructor() {
-    this.view = new DataView(new ArrayBuffer(64));
-    this.bytes = new Uint8Array(this.view.buffer);
+  constructor(initialSize = 256) {
+    this.bytes = new Uint8Array(Math.max(initialSize, 16));
   }
 
-  public writeUInt8(val: number) {
+  writeUInt8(val: number) {
     this.ensureSize(1);
-    this.view.setUint8(this.pos, val);
-    this.pos += 1;
+    this.bytes[this.pos++] = val;
     return this;
   }
 
-  public writeUInt32(val: number) {
-    this.ensureSize(4);
-    this.view.setUint32(this.pos, val);
-    this.pos += 4;
+  writeUInt16(val: number) {
+    this.ensureSize(2);
+    this.view.setUint16(this.pos, val);
+    this.pos += 2;
     return this;
   }
 
-  public writeUInt64(val: bigint) {
-    this.ensureSize(8);
-    this.view.setBigUint64(this.pos, val);
-    this.pos += 8;
+  writeUInt32(val: number) {
+    this.ensureSize(4);
+    this.view.setUint32(this.pos, val);
+    this.pos += 4;
     return this;
   }
 
-  public writeUVarint(val: number) {
+  writeUVarint(val: number) {
     if (val < 0x80) {
-      this.ensureSize(1);
-      this.view.setUint8(this.pos, val);
-      this.pos += 1;
+      this.writeUInt8(val);
     } else if (val < 0x4000) {
-      this.ensureSize(2);
-      this.view.setUint16(this.pos, (val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
-      this.pos += 2;
+      this.writeUInt16((val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
     } else if (val < 0x200000) {
-      this.ensureSize(3);
-      this.view.setUint8(this.pos, (val >> 14) | 0x80);
-      this.view.setUint16(this.pos + 1, (val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
-      this.pos += 3;
+      this.writeUInt8((val >> 14) | 0x80);
+      this.writeUInt16((val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
     } else if (val < 0x10000000) {
-      this.ensureSize(4);
-      this.view.setUint32(
-        this.pos,
+      this.writeUInt32(
         (val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000
       );
-      this.pos += 4;
     } else if (val < 0x800000000) {
-      this.ensureSize(5);
-      this.view.setUint8(this.pos, Math.floor(val / Math.pow(2, 28)) | 0x80);
-      this.view.setUint32(
-        this.pos + 1,
+      this.writeUInt8(Math.floor(val / 0x10000000) | 0x80);
+      this.writeUInt32(
         (val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000
       );
-      this.pos += 5;
     } else if (val < 0x40000000000) {
-      this.ensureSize(6);
-      const shiftedVal = Math.floor(val / Math.pow(2, 28));
-      this.view.setUint16(this.pos, (shiftedVal & 0x7f) | ((shiftedVal & 0x3f80) << 1) | 0x8080);
-      this.view.setUint32(
-        this.pos + 2,
+      const shiftedVal = Math.floor(val / 0x10000000);
+      this.writeUInt16((shiftedVal & 0x7f) | ((shiftedVal & 0x3f80) << 1) | 0x8080);
+      this.writeUInt32(
         (val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000
       );
-      this.pos += 6;
     } else {
       throw new Error("Value out of range");
     }
     return this;
   }
 
-  public writeVarint(val: number) {
-    const bigval = BigInt(val);
-    this.writeUVarint(Number((bigval >> 63n) ^ (bigval << 1n)));
+  writeVarint(val: number) {
+    this.writeUVarint((val << 1) ^ (val >> 31));
     return this;
   }
 
-  public writeFloat(val: number) {
+  writeFloat(val: number) {
     this.ensureSize(4);
     this.view.setFloat32(this.pos, val, true);
     this.pos += 4;
     return this;
   }
 
-  public writeBits(bits: boolean[]) {
+  writeBits(bits: boolean[]) {
+    const numBytes = Math.ceil(bits.length / 8);
+    this.ensureSize(numBytes);
     for (let i = 0; i < bits.length; i += 8) {
       let byte = 0;
-      for (let j = 0; j < 8; j++) {
-        if (i + j == bits.length) {
-          break;
+      for (let j = 0; j < 8 && i + j < bits.length; j++) {
+        if (bits[i + j]) {
+          byte |= 1 << j;
         }
-        byte |= (bits[i + j] ? 1 : 0) << j;
       }
-      this.writeUInt8(byte);
+      this.bytes[this.pos++] = byte;
     }
     return this;
   }
 
-  public writeStringAscii(val: string) {
+  writeStringAscii(val: string) {
     if (val.length === 0) {
       return this;
     }
     this.ensureSize(val.length);
     for (let i = 0; i < val.length; i++) {
-      this.view.setUint8(this.pos++, val.charCodeAt(i));
+      this.bytes[this.pos++] = val.charCodeAt(i);
     }
     return this;
   }
 
-  public writeStringUtf8(val: string) {
-    if (val.length > 0) {
-      const byteSize = utf8Size(val);
-      this.writeUVarint(byteSize);
-      this.ensureSize(byteSize);
+  writeStringUtf8(val: string, len?: number) {
+    if (len != null) {
+      if (len === 0) {
+        return this;
+      }
+      this.ensureSize(len);
       pack(val, this.bytes, this.pos);
-      this.pos += byteSize;
-    } else {
-      this.writeUInt8(0);
+      this.pos += len;
+      return this;
+    }
+    if (val.length === 0) {
+      this.writeUVarint(0);
+      return this;
     }
+    const byteSize = utf8Size(val);
+    this.writeUVarint(byteSize);
+    this.ensureSize(byteSize);
+    pack(val, this.bytes, this.pos);
+    this.pos += byteSize;
     return this;
   }
 
-  public writeBuffer(buf: Uint8Array) {
+  writeBuffer(buf: Uint8Array) {
     this.ensureSize(buf.length);
     this.bytes.set(buf, this.pos);
     this.pos += buf.length;
     return this;
   }
 
-  public toBuffer() {
+  concat(other: Writer) {
+    const otherLen = other.pos;
+    this.ensureSize(otherLen);
+    if (otherLen < 64) {
+      for (let i = 0; i < otherLen; i++) {
+        this.bytes[this.pos++] = other.bytes[i];
+      }
+    } else {
+      this.bytes.set(other.bytes.subarray(0, otherLen), this.pos);
+      this.pos += otherLen;
+    }
+    return this;
+  }
+
+  toBuffer() {
     return this.bytes.subarray(0, this.pos);
   }
 
+  get size(): number {
+    return this.pos;
+  }
+
   private ensureSize(size: number) {
-    while (this.view.byteLength < this.pos + size) {
-      const newView = new DataView(new ArrayBuffer(this.view.byteLength * 2));
-      const newBytes = new Uint8Array(newView.buffer);
-      newBytes.set(this.bytes);
-      this.view = newView;
-      this.bytes = newBytes;
+    if (this.bytes.length >= this.pos + size) {
+      return;
+    }
+    let newSize = this.bytes.length * 2;
+    while (newSize < this.pos + size) {
+      newSize *= 2;
+    }
+    const newBytes = new Uint8Array(newSize);
+    newBytes.set(this.bytes);
+    this.bytes = newBytes;
+    this._view = null;
+  }
+
+  private get view(): DataView {
+    if (!this._view) {
+      this._view = new DataView(this.bytes.buffer);
     }
+    return this._view;
   }
 }
 
 export class Reader {
   private pos = 0;
-  private view: DataView;
   private bytes: Uint8Array;
+  private view: DataView;
 
-  public constructor(buf: ArrayBufferView) {
+  constructor(buf: Uint8Array) {
+    this.bytes = buf;
     this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    this.bytes = new Uint8Array(this.view.buffer, buf.byteOffset, buf.byteLength);
   }
 
-  public readUInt8() {
-    const val = this.view.getUint8(this.pos);
-    this.pos += 1;
-    return val;
+  readUInt8() {
+    return this.bytes[this.pos++];
   }
 
-  public readUInt32() {
+  readUInt32() {
     const val = this.view.getUint32(this.pos);
     this.pos += 4;
     return val;
   }
 
-  public readUInt64() {
-    const val = this.view.getBigUint64(this.pos);
-    this.pos += 8;
-    return val;
-  }
-
-  public readUVarint() {
+  readUVarint() {
     let val = 0;
     while (true) {
-      let byte = this.view.getUint8(this.pos++);
+      const byte = this.readUInt8();
       if (byte < 0x80) {
         return val + byte;
       }
@@ -188,43 +201,42 @@ export class Reader {
     }
   }
 
-  public readVarint() {
-    const val = BigInt(this.readUVarint());
-    return Number((val >> 1n) ^ -(val & 1n));
+  readVarint() {
+    const val = this.readUVarint();
+    return (val >>> 1) ^ -(val & 1);
   }
 
-  public readFloat() {
+  readFloat() {
     const val = this.view.getFloat32(this.pos, true);
     this.pos += 4;
     return val;
   }
 
-  public readBits(numBits: number) {
+  readBits(numBits: number) {
     const numBytes = Math.ceil(numBits / 8);
-    const bytes = this.bytes.slice(this.pos, this.pos + numBytes);
     const bits: boolean[] = [];
-    for (const byte of bytes) {
-      for (let i = 0; i < 8 && bits.length < numBits; i++) {
-        bits.push(((byte >> i) & 1) === 1);
+    for (let i = 0; i < numBytes; i++) {
+      const byte = this.readUInt8();
+      for (let j = 0; j < 8 && bits.length < numBits; j++) {
+        bits.push(((byte >> j) & 1) === 1);
       }
     }
-    this.pos += numBytes;
     return bits;
   }
 
-  public readStringAscii(len: number) {
+  readStringAscii(len: number) {
     if (len === 0) {
       return "";
     }
     let val = "";
     for (let i = 0; i < len; i++) {
-      val += String.fromCharCode(this.view.getUint8(this.pos++));
+      val += String.fromCharCode(this.readUInt8());
     }
     return val;
   }
 
-  public readStringUtf8(len?: number) {
-    if (len === undefined) {
+  readStringUtf8(len?: number) {
+    if (len == null) {
       len = this.readUVarint();
     }
     if (len === 0) {
@@ -235,13 +247,13 @@ export class Reader {
     return val;
   }
 
-  public readBuffer(numBytes: number) {
+  readBuffer(numBytes: number) {
     const bytes = this.bytes.slice(this.pos, this.pos + numBytes);
     this.pos += numBytes;
     return bytes;
   }
 
-  public remaining() {
-    return this.view.byteLength - this.pos;
+  remaining() {
+    return this.bytes.length - this.pos;
   }
 }

package/lib/index.d.ts

@@ -1,29 +1,31 @@
 export declare class Writer {
     private pos;
-    private view;
     private bytes;
-    constructor();
+    private _view;
+    constructor(initialSize?: number);
     writeUInt8(val: number): this;
+    writeUInt16(val: number): this;
     writeUInt32(val: number): this;
-    writeUInt64(val: bigint): this;
     writeUVarint(val: number): this;
     writeVarint(val: number): this;
     writeFloat(val: number): this;
     writeBits(bits: boolean[]): this;
     writeStringAscii(val: string): this;
-    writeStringUtf8(val: string): this;
+    writeStringUtf8(val: string, len?: number): this;
     writeBuffer(buf: Uint8Array): this;
+    concat(other: Writer): this;
     toBuffer(): Uint8Array;
+    get size(): number;
     private ensureSize;
+    private get view();
 }
 export declare class Reader {
     private pos;
-    private view;
     private bytes;
-    constructor(buf: ArrayBufferView);
+    private view;
+    constructor(buf: Uint8Array);
     readUInt8(): number;
     readUInt32(): number;
-    readUInt64(): bigint;
     readUVarint(): number;
     readVarint(): number;
     readFloat(): number;

package/lib/index.js

@@ -2,16 +2,20 @@ import { pack, unpack } from "./utf8-buffer.js";
 import utf8Size from "utf8-buffer-size";
 export class Writer {
     pos = 0;
-    view;
     bytes;
-    constructor() {
-        this.view = new DataView(new ArrayBuffer(64));
-        this.bytes = new Uint8Array(this.view.buffer);
+    _view = null;
+    constructor(initialSize = 256) {
+        this.bytes = new Uint8Array(Math.max(initialSize, 16));
     }
     writeUInt8(val) {
         this.ensureSize(1);
-        this.view.setUint8(this.pos, val);
-        this.pos += 1;
+        this.bytes[this.pos++] = val;
+        return this;
+    }
+    writeUInt16(val) {
+        this.ensureSize(2);
+        this.view.setUint16(this.pos, val);
+        this.pos += 2;
         return this;
     }
     writeUInt32(val) {
@@ -20,46 +24,28 @@ export class Writer {
         this.pos += 4;
         return this;
     }
-    writeUInt64(val) {
-        this.ensureSize(8);
-        this.view.setBigUint64(this.pos, val);
-        this.pos += 8;
-        return this;
-    }
     writeUVarint(val) {
         if (val < 0x80) {
-            this.ensureSize(1);
-            this.view.setUint8(this.pos, val);
-            this.pos += 1;
+            this.writeUInt8(val);
         }
         else if (val < 0x4000) {
-            this.ensureSize(2);
-            this.view.setUint16(this.pos, (val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
-            this.pos += 2;
+            this.writeUInt16((val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
         }
         else if (val < 0x200000) {
-            this.ensureSize(3);
-            this.view.setUint8(this.pos, (val >> 14) | 0x80);
-            this.view.setUint16(this.pos + 1, (val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
-            this.pos += 3;
+            this.writeUInt8((val >> 14) | 0x80);
+            this.writeUInt16((val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
         }
         else if (val < 0x10000000) {
-            this.ensureSize(4);
-            this.view.setUint32(this.pos, (val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000);
-            this.pos += 4;
+            this.writeUInt32((val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000);
         }
         else if (val < 0x800000000) {
-            this.ensureSize(5);
-            this.view.setUint8(this.pos, Math.floor(val / Math.pow(2, 28)) | 0x80);
-            this.view.setUint32(this.pos + 1, (val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000);
-            this.pos += 5;
+            this.writeUInt8(Math.floor(val / 0x10000000) | 0x80);
+            this.writeUInt32((val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000);
         }
         else if (val < 0x40000000000) {
-            this.ensureSize(6);
-            const shiftedVal = Math.floor(val / Math.pow(2, 28));
-            this.view.setUint16(this.pos, (shiftedVal & 0x7f) | ((shiftedVal & 0x3f80) << 1) | 0x8080);
-            this.view.setUint32(this.pos + 2, (val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000);
-            this.pos += 6;
+            const shiftedVal = Math.floor(val / 0x10000000);
+            this.writeUInt16((shiftedVal & 0x7f) | ((shiftedVal & 0x3f80) << 1) | 0x8080);
+            this.writeUInt32((val & 0x7f) | ((val & 0x3f80) << 1) | ((val & 0x1fc000) << 2) | ((val & 0xfe00000) << 3) | 0x80808000);
         }
         else {
             throw new Error("Value out of range");
@@ -67,8 +53,7 @@ export class Writer {
         return this;
     }
     writeVarint(val) {
-        const bigval = BigInt(val);
-        this.writeUVarint(Number((bigval >> 63n) ^ (bigval << 1n)));
+        this.writeUVarint((val << 1) ^ (val >> 31));
         return this;
     }
     writeFloat(val) {
@@ -78,15 +63,16 @@ export class Writer {
         return this;
     }
     writeBits(bits) {
+        const numBytes = Math.ceil(bits.length / 8);
+        this.ensureSize(numBytes);
         for (let i = 0; i < bits.length; i += 8) {
             let byte = 0;
-            for (let j = 0; j < 8; j++) {
-                if (i + j == bits.length) {
-                    break;
+            for (let j = 0; j < 8 && i + j < bits.length; j++) {
+                if (bits[i + j]) {
+                    byte |= 1 << j;
                 }
-                byte |= (bits[i + j] ? 1 : 0) << j;
             }
-            this.writeUInt8(byte);
+            this.bytes[this.pos++] = byte;
         }
         return this;
     }
@@ -96,21 +82,29 @@ export class Writer {
         }
         this.ensureSize(val.length);
         for (let i = 0; i < val.length; i++) {
-            this.view.setUint8(this.pos++, val.charCodeAt(i));
+            this.bytes[this.pos++] = val.charCodeAt(i);
         }
         return this;
     }
-    writeStringUtf8(val) {
-        if (val.length > 0) {
-            const byteSize = utf8Size(val);
-            this.writeUVarint(byteSize);
-            this.ensureSize(byteSize);
+    writeStringUtf8(val, len) {
+        if (len != null) {
+            if (len === 0) {
+                return this;
+            }
+            this.ensureSize(len);
             pack(val, this.bytes, this.pos);
-            this.pos += byteSize;
+            this.pos += len;
+            return this;
         }
-        else {
-            this.writeUInt8(0);
+        if (val.length === 0) {
+            this.writeUVarint(0);
+            return this;
         }
+        const byteSize = utf8Size(val);
+        this.writeUVarint(byteSize);
+        this.ensureSize(byteSize);
+        pack(val, this.bytes, this.pos);
+        this.pos += byteSize;
         return this;
     }
     writeBuffer(buf) {
@@ -119,46 +113,66 @@ export class Writer {
         this.pos += buf.length;
         return this;
     }
+    concat(other) {
+        const otherLen = other.pos;
+        this.ensureSize(otherLen);
+        if (otherLen < 64) {
+            for (let i = 0; i < otherLen; i++) {
+                this.bytes[this.pos++] = other.bytes[i];
+            }
+        }
+        else {
+            this.bytes.set(other.bytes.subarray(0, otherLen), this.pos);
+            this.pos += otherLen;
+        }
+        return this;
+    }
     toBuffer() {
         return this.bytes.subarray(0, this.pos);
     }
+    get size() {
+        return this.pos;
+    }
     ensureSize(size) {
-        while (this.view.byteLength < this.pos + size) {
-            const newView = new DataView(new ArrayBuffer(this.view.byteLength * 2));
-            const newBytes = new Uint8Array(newView.buffer);
-            newBytes.set(this.bytes);
-            this.view = newView;
-            this.bytes = newBytes;
+        if (this.bytes.length >= this.pos + size) {
+            return;
+        }
+        let newSize = this.bytes.length * 2;
+        while (newSize < this.pos + size) {
+            newSize *= 2;
         }
+        const newBytes = new Uint8Array(newSize);
+        newBytes.set(this.bytes);
+        this.bytes = newBytes;
+        this._view = null;
+    }
+    get view() {
+        if (!this._view) {
+            this._view = new DataView(this.bytes.buffer);
+        }
+        return this._view;
     }
 }
 export class Reader {
     pos = 0;
-    view;
     bytes;
+    view;
     constructor(buf) {
+        this.bytes = buf;
         this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        this.bytes = new Uint8Array(this.view.buffer, buf.byteOffset, buf.byteLength);
     }
     readUInt8() {
-        const val = this.view.getUint8(this.pos);
-        this.pos += 1;
-        return val;
+        return this.bytes[this.pos++];
     }
     readUInt32() {
         const val = this.view.getUint32(this.pos);
         this.pos += 4;
         return val;
     }
-    readUInt64() {
-        const val = this.view.getBigUint64(this.pos);
-        this.pos += 8;
-        return val;
-    }
     readUVarint() {
         let val = 0;
         while (true) {
-            let byte = this.view.getUint8(this.pos++);
+            const byte = this.readUInt8();
             if (byte < 0x80) {
                 return val + byte;
             }
@@ -166,8 +180,8 @@ export class Reader {
         }
     }
     readVarint() {
-        const val = BigInt(this.readUVarint());
-        return Number((val >> 1n) ^ -(val & 1n));
+        const val = this.readUVarint();
+        return (val >>> 1) ^ -(val & 1);
     }
     readFloat() {
         const val = this.view.getFloat32(this.pos, true);
@@ -176,14 +190,13 @@ export class Reader {
     }
     readBits(numBits) {
         const numBytes = Math.ceil(numBits / 8);
-        const bytes = this.bytes.slice(this.pos, this.pos + numBytes);
         const bits = [];
-        for (const byte of bytes) {
-            for (let i = 0; i < 8 && bits.length < numBits; i++) {
-                bits.push(((byte >> i) & 1) === 1);
+        for (let i = 0; i < numBytes; i++) {
+            const byte = this.readUInt8();
+            for (let j = 0; j < 8 && bits.length < numBits; j++) {
+                bits.push(((byte >> j) & 1) === 1);
             }
         }
-        this.pos += numBytes;
         return bits;
     }
     readStringAscii(len) {
@@ -192,12 +205,12 @@ export class Reader {
         }
         let val = "";
         for (let i = 0; i < len; i++) {
-            val += String.fromCharCode(this.view.getUint8(this.pos++));
+            val += String.fromCharCode(this.readUInt8());
         }
         return val;
     }
     readStringUtf8(len) {
-        if (len === undefined) {
+        if (len == null) {
             len = this.readUVarint();
         }
         if (len === 0) {
@@ -213,6 +226,6 @@ export class Reader {
         return bytes;
     }
     remaining() {
-        return this.view.byteLength - this.pos;
+        return this.bytes.length - this.pos;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bin-serde",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "A low level library for efficiently writing and reading binary data in javascript",
   "type": "module",
   "main": "lib/index.js",