bin-serde 1.7.5 → 1.7.7

package/index.ts

@@ -9,6 +9,8 @@ let slabOffset = 0;
 
 const f32 = new Float32Array(1);
 const f32u8 = new Uint8Array(f32.buffer);
+const copyBuffer =
+  typeof Buffer !== "undefined" ? (buf: Uint8Array) => Buffer.from(buf) : (buf: Uint8Array) => buf.slice();
 
 function allocFromSlab(size: number): Uint8Array {
   if (size > MAX_POOLED) {
@@ -154,8 +156,7 @@ export class Writer {
   }
 
   toBuffer() {
-    const view = this.bytes.subarray(0, this.pos);
-    return typeof Buffer !== "undefined" ? Buffer.from(view) : view.slice();
+    return copyBuffer(this.bytes.subarray(0, this.pos));
   }
 
   reset() {

package/lib/index.js

@@ -6,6 +6,7 @@ let slab = allocUint8Array(SLAB_SIZE);
 let slabOffset = 0;
 const f32 = new Float32Array(1);
 const f32u8 = new Uint8Array(f32.buffer);
+const copyBuffer = typeof Buffer !== "undefined" ? (buf) => Buffer.from(buf) : (buf) => buf.slice();
 function allocFromSlab(size) {
     if (size > MAX_POOLED) {
         // Too large for pool, allocate directly
@@ -136,8 +137,7 @@ export class Writer {
         return this;
     }
     toBuffer() {
-        const view = this.bytes.subarray(0, this.pos);
-        return typeof Buffer !== "undefined" ? Buffer.from(view) : view.slice();
+        return copyBuffer(this.bytes.subarray(0, this.pos));
     }
     reset() {
         this.pos = 0;

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.5",
+  "version": "1.7.7",
   "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 {