bin-serde 1.7.6 → 1.7.8

package/index.ts

@@ -288,6 +288,13 @@ export class Reader {
     return this.bytes.length - this.pos;
   }
 
+  reset(buf: Uint8Array) {
+    this.bytes = buf;
+    this.pos = 0;
+    this._view = null;
+    return this;
+  }
+
   private get view(): DataView {
     if (!this._view) {
       this._view = new DataView(this.bytes.buffer, this.bytes.byteOffset);

package/lib/index.d.ts

@@ -36,5 +36,6 @@ export declare class Reader {
     readStringUtf8(len?: number): string;
     readBuffer(numBytes: number): Uint8Array<ArrayBuffer>;
     remaining(): number;
+    reset(buf: Uint8Array): this;
     private get view();
 }

package/lib/index.js

@@ -251,6 +251,12 @@ export class Reader {
     remaining() {
         return this.bytes.length - this.pos;
     }
+    reset(buf) {
+        this.bytes = buf;
+        this.pos = 0;
+        this._view = null;
+        return this;
+    }
     get view() {
         if (!this._view) {
             this._view = new DataView(this.bytes.buffer, this.bytes.byteOffset);

package/lib/utf8-buffer.js

@@ -1,17 +1,41 @@
 const textDecoder = new TextDecoder();
 const hasBuffer = typeof Buffer !== "undefined";
 export function unpack(buffer, start = 0, end = buffer.length) {
-    if (end - start < 1)
+    const len = end - start;
+    if (len < 1)
         return "";
-    // Fast path: use Buffer.toString() in Node.js (avoids subarray overhead)
+    // Node.js: use Buffer.toString()
     if (hasBuffer && Buffer.isBuffer(buffer)) {
         return buffer.toString("utf8", start, end);
     }
-    // Standard path: TextDecoder
-    if (start === 0 && end === buffer.length) {
-        return textDecoder.decode(buffer);
+    // Long strings: use TextDecoder
+    if (len > 64) {
+        return textDecoder.decode(buffer.subarray(start, end));
     }
-    return textDecoder.decode(buffer.subarray(start, end));
+    // Short strings: use pure JS
+    const chunks = [];
+    let i = 0;
+    let t;
+    while (start < end) {
+        t = buffer[start++];
+        if (t < 128) {
+            chunks[i++] = t;
+        }
+        else if (t > 191 && t < 224) {
+            chunks[i++] = ((t & 31) << 6) | (buffer[start++] & 63);
+        }
+        else if (t > 239 && t < 365) {
+            t =
+                (((t & 7) << 18) | ((buffer[start++] & 63) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63)) -
+                    0x10000;
+            chunks[i++] = 0xd800 + (t >> 10);
+            chunks[i++] = 0xdc00 + (t & 1023);
+        }
+        else {
+            chunks[i++] = ((t & 15) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63);
+        }
+    }
+    return String.fromCharCode.apply(String, chunks);
 }
 export function pack(str, buffer, index = 0) {
     let c1, c2;

package/package.json

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

package/utf8-buffer.ts

@@ -2,18 +2,40 @@ const textDecoder = new TextDecoder();
 const hasBuffer = typeof Buffer !== "undefined";
 
 export function unpack(buffer: Uint8Array, start = 0, end = buffer.length): string {
-  if (end - start < 1) return "";
+  const len = end - start;
+  if (len < 1) return "";
 
-  // Fast path: use Buffer.toString() in Node.js (avoids subarray overhead)
+  // Node.js: use Buffer.toString()
   if (hasBuffer && Buffer.isBuffer(buffer)) {
     return buffer.toString("utf8", start, end);
   }
 
-  // Standard path: TextDecoder
-  if (start === 0 && end === buffer.length) {
-    return textDecoder.decode(buffer);
+  // Long strings: use TextDecoder
+  if (len > 64) {
+    return textDecoder.decode(buffer.subarray(start, end));
   }
-  return textDecoder.decode(buffer.subarray(start, end));
+
+  // Short strings: use pure JS
+  const chunks: number[] = [];
+  let i = 0;
+  let t: number;
+  while (start < end) {
+    t = buffer[start++]!;
+    if (t < 128) {
+      chunks[i++] = t;
+    } else if (t > 191 && t < 224) {
+      chunks[i++] = ((t & 31) << 6) | (buffer[start++]! & 63);
+    } else if (t > 239 && t < 365) {
+      t =
+        (((t & 7) << 18) | ((buffer[start++]! & 63) << 12) | ((buffer[start++]! & 63) << 6) | (buffer[start++]! & 63)) -
+        0x10000;
+      chunks[i++] = 0xd800 + (t >> 10);
+      chunks[i++] = 0xdc00 + (t & 1023);
+    } else {
+      chunks[i++] = ((t & 15) << 12) | ((buffer[start++]! & 63) << 6) | (buffer[start++]! & 63);
+    }
+  }
+  return String.fromCharCode.apply(String, chunks);
 }
 
 export function pack(str: string, buffer: Uint8Array, index = 0): number {