bin-serde 1.0.0

package/README.md

@@ -0,0 +1 @@
+# bin-serde

package/index.ts

@@ -0,0 +1,206 @@
+import * as utf8 from "utf8-buffer";
+import utf8Size from "utf8-buffer-size";
+const { pack, unpack } = (utf8 as any).default ?? utf8;
+
+export class Writer {
+  private pos = 0;
+  private view = new DataView(new ArrayBuffer(64));
+  private bytes = new Uint8Array(this.view.buffer);
+
+  public writeUInt8(val: number) {
+    this.ensureSize(1);
+    this.view.setUint8(this.pos, val);
+    this.pos += 1;
+    return this;
+  }
+
+  public writeUInt32(val: number) {
+    this.ensureSize(4);
+    this.view.setUint32(this.pos, val);
+    this.pos += 4;
+    return this;
+  }
+
+  public writeUVarint(val: number) {
+    if (val < 0x80) {
+      this.ensureSize(1);
+      this.view.setUint8(this.pos, val);
+      this.pos += 1;
+    } else if (val < 0x4000) {
+      this.ensureSize(2);
+      this.view.setUint16(this.pos, (val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
+      this.pos += 2;
+    } 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;
+    } 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;
+    } 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;
+    } 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;
+    } 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)));
+    return this;
+  }
+
+  public writeFloat(val: number) {
+    this.ensureSize(4);
+    this.view.setFloat32(this.pos, val, true);
+    this.pos += 4;
+    return this;
+  }
+
+  public writeBits(bits: boolean[]) {
+    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;
+        }
+        byte |= (bits[i + j] ? 1 : 0) << j;
+      }
+      this.writeUInt8(byte);
+    }
+    return this;
+  }
+
+  public writeString(val: string) {
+    if (val.length > 0) {
+      const byteSize = utf8Size(val);
+      this.writeUVarint(byteSize);
+      this.ensureSize(byteSize);
+      pack(val, this.bytes, this.pos);
+      this.pos += byteSize;
+    } else {
+      this.writeUInt8(0);
+    }
+    return this;
+  }
+
+  public writeBuffer(buf: Uint8Array) {
+    this.ensureSize(buf.length);
+    this.bytes.set(buf, this.pos);
+    this.pos += buf.length;
+    return this;
+  }
+
+  public toBuffer() {
+    return this.bytes.subarray(0, 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;
+    }
+  }
+}
+
+export class Reader {
+  private pos = 0;
+  private view: DataView;
+  private bytes: Uint8Array;
+
+  public constructor(buf: ArrayBufferView) {
+    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;
+  }
+
+  public readUInt32() {
+    const val = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return val;
+  }
+
+  public readUVarint() {
+    let val = 0;
+    while (true) {
+      let byte = this.view.getUint8(this.pos++);
+      if (byte < 0x80) {
+        return val + byte;
+      }
+      val = (val + (byte & 0x7f)) * 128;
+    }
+  }
+
+  public readVarint() {
+    const val = BigInt(this.readUVarint());
+    return Number((val >> 1n) ^ -(val & 1n));
+  }
+
+  public readFloat() {
+    const val = this.view.getFloat32(this.pos, true);
+    this.pos += 4;
+    return val;
+  }
+
+  public 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);
+      }
+    }
+    this.pos += numBytes;
+    return bits;
+  }
+
+  public readString() {
+    const len = this.readUVarint();
+    if (len === 0) {
+      return "";
+    }
+    const val = unpack(this.bytes, this.pos, this.pos + len);
+    this.pos += len;
+    return val;
+  }
+
+  public 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;
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+export declare class Writer {
+    private pos;
+    private view;
+    private bytes;
+    writeUInt8(val: number): this;
+    writeUInt32(val: number): this;
+    writeUVarint(val: number): this;
+    writeVarint(val: number): this;
+    writeFloat(val: number): this;
+    writeBits(bits: boolean[]): this;
+    writeString(val: string): this;
+    writeBuffer(buf: Uint8Array): this;
+    toBuffer(): Uint8Array;
+    private ensureSize;
+}
+export declare class Reader {
+    private pos;
+    private view;
+    private bytes;
+    constructor(buf: ArrayBufferView);
+    readUInt8(): number;
+    readUInt32(): number;
+    readUVarint(): number;
+    readVarint(): number;
+    readFloat(): number;
+    readBits(numBits: number): boolean[];
+    readString(): any;
+    readBuffer(numBytes: number): Uint8Array;
+    remaining(): number;
+}

package/lib/index.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reader = exports.Writer = void 0;
+const utf8 = require("utf8-buffer");
+const utf8_buffer_size_1 = require("utf8-buffer-size");
+const { pack, unpack } = utf8.default ?? utf8;
+class Writer {
+    pos = 0;
+    view = new DataView(new ArrayBuffer(64));
+    bytes = new Uint8Array(this.view.buffer);
+    writeUInt8(val) {
+        this.ensureSize(1);
+        this.view.setUint8(this.pos, val);
+        this.pos += 1;
+        return this;
+    }
+    writeUInt32(val) {
+        this.ensureSize(4);
+        this.view.setUint32(this.pos, val);
+        this.pos += 4;
+        return this;
+    }
+    writeUVarint(val) {
+        if (val < 0x80) {
+            this.ensureSize(1);
+            this.view.setUint8(this.pos, val);
+            this.pos += 1;
+        }
+        else if (val < 0x4000) {
+            this.ensureSize(2);
+            this.view.setUint16(this.pos, (val & 0x7f) | ((val & 0x3f80) << 1) | 0x8000);
+            this.pos += 2;
+        }
+        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;
+        }
+        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;
+        }
+        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;
+        }
+        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;
+        }
+        else {
+            throw new Error("Value out of range");
+        }
+        return this;
+    }
+    writeVarint(val) {
+        const bigval = BigInt(val);
+        this.writeUVarint(Number((bigval >> 63n) ^ (bigval << 1n)));
+        return this;
+    }
+    writeFloat(val) {
+        this.ensureSize(4);
+        this.view.setFloat32(this.pos, val, true);
+        this.pos += 4;
+        return this;
+    }
+    writeBits(bits) {
+        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;
+                }
+                byte |= (bits[i + j] ? 1 : 0) << j;
+            }
+            this.writeUInt8(byte);
+        }
+        return this;
+    }
+    writeString(val) {
+        if (val.length > 0) {
+            const byteSize = (0, utf8_buffer_size_1.default)(val);
+            this.writeUVarint(byteSize);
+            this.ensureSize(byteSize);
+            pack(val, this.bytes, this.pos);
+            this.pos += byteSize;
+        }
+        else {
+            this.writeUInt8(0);
+        }
+        return this;
+    }
+    writeBuffer(buf) {
+        this.ensureSize(buf.length);
+        this.bytes.set(buf, this.pos);
+        this.pos += buf.length;
+        return this;
+    }
+    toBuffer() {
+        return this.bytes.subarray(0, 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;
+        }
+    }
+}
+exports.Writer = Writer;
+class Reader {
+    pos = 0;
+    view;
+    bytes;
+    constructor(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;
+    }
+    readUInt32() {
+        const val = this.view.getUint32(this.pos);
+        this.pos += 4;
+        return val;
+    }
+    readUVarint() {
+        let val = 0;
+        while (true) {
+            let byte = this.view.getUint8(this.pos++);
+            if (byte < 0x80) {
+                return val + byte;
+            }
+            val = (val + (byte & 0x7f)) * 128;
+        }
+    }
+    readVarint() {
+        const val = BigInt(this.readUVarint());
+        return Number((val >> 1n) ^ -(val & 1n));
+    }
+    readFloat() {
+        const val = this.view.getFloat32(this.pos, true);
+        this.pos += 4;
+        return val;
+    }
+    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);
+            }
+        }
+        this.pos += numBytes;
+        return bits;
+    }
+    readString() {
+        const len = this.readUVarint();
+        if (len === 0) {
+            return "";
+        }
+        const val = unpack(this.bytes, this.pos, this.pos + len);
+        this.pos += len;
+        return val;
+    }
+    readBuffer(numBytes) {
+        const bytes = this.bytes.slice(this.pos, this.pos + numBytes);
+        this.pos += numBytes;
+        return bytes;
+    }
+    remaining() {
+        return this.view.byteLength - this.pos;
+    }
+}
+exports.Reader = Reader;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "bin-serde",
+  "version": "1.0.0",
+  "description": "A low level library for efficiently writing and reading binary data in javascript",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hathora/bin-serde.git"
+  },
+  "keywords": [
+    "binary",
+    "serialization",
+    "serde",
+    "encode",
+    "decode"
+  ],
+  "author": "Harsh Pandey",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hathora/bin-serde/issues"
+  },
+  "homepage": "https://github.com/hathora/bin-serde#readme",
+  "dependencies": {
+    "utf8-buffer": "^1.0.0",
+    "utf8-buffer-size": "^0.0.4"
+  },
+  "devDependencies": {
+    "typescript": "^4.5.5"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./lib",
+    "strict": true
+  },
+  "include": ["index.ts"]
+}