bin-serde 1.6.4 → 1.6.6

package/index.ts

@@ -224,11 +224,10 @@ export class Writer {
 export class Reader {
   private pos = 0;
   private bytes: Uint8Array;
-  private view: DataView;
+  private _view: DataView | null = null; // lazily allocated
 
   constructor(buf: Uint8Array) {
     this.bytes = buf;
-    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
   }
 
   readUInt8() {
@@ -315,4 +314,11 @@ export class Reader {
   remaining() {
     return this.bytes.length - this.pos;
   }
+
+  private get view(): DataView {
+    if (!this._view) {
+      this._view = new DataView(this.bytes.buffer, this.bytes.byteOffset);
+    }
+    return this._view;
+  }
 }

package/lib/index.d.ts

@@ -22,7 +22,7 @@ export declare class Writer {
 export declare class Reader {
     private pos;
     private bytes;
-    private view;
+    private _view;
     constructor(buf: Uint8Array);
     readUInt8(): number;
     readUInt16(): number;
@@ -35,4 +35,5 @@ export declare class Reader {
     readStringUtf8(len?: number): string;
     readBuffer(numBytes: number): Uint8Array;
     remaining(): number;
+    private get view();
 }

package/lib/index.js

@@ -199,10 +199,9 @@ export class Writer {
 export class Reader {
     pos = 0;
     bytes;
-    view;
+    _view = null; // lazily allocated
     constructor(buf) {
         this.bytes = buf;
-        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
     }
     readUInt8() {
         return this.bytes[this.pos++];
@@ -278,4 +277,10 @@ export class Reader {
     remaining() {
         return this.bytes.length - this.pos;
     }
+    get view() {
+        if (!this._view) {
+            this._view = new DataView(this.bytes.buffer, this.bytes.byteOffset);
+        }
+        return this._view;
+    }
 }

package/lib/utf8-buffer.d.ts

@@ -1,28 +1,2 @@
-/**
- * @fileoverview Functions to serialize and deserialize UTF-8 strings.
- * @see https://github.com/rochars/utf8-buffer
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- */
-/** @module utf8-buffer */
-/**
- * Read a string of UTF-8 characters from a byte buffer.
- * Invalid characters are replaced with 'REPLACEMENT CHARACTER' (U+FFFD).
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://stackoverflow.com/a/34926911
- * @param {!Uint8Array|!Array<number>} buffer A byte buffer.
- * @param {number=} start The buffer index to start reading.
- * @param {?number=} end The buffer index to stop reading.
- *   Assumes the buffer length if undefined.
- * @return {string}
- */
-export function unpack(buffer: Uint8Array | Array<number>, start?: number | undefined, end?: (number | null) | undefined): string;
-/**
- * Write a string of UTF-8 characters to a byte buffer.
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- * @param {string} str The string to pack.
- * @param {!Uint8Array|!Array<number>} buffer The buffer to pack the string to.
- * @param {number=} index The buffer index to start writing.
- * @return {number} The next index to write in the buffer.
- */
-export function pack(str: string, buffer: Uint8Array | Array<number>, index?: number | undefined): number;
+export declare function unpack(buffer: Uint8Array, start?: number, end?: number): string;
+export declare function pack(str: string, buffer: Uint8Array, index?: number): number;

package/lib/utf8-buffer.js

@@ -1,149 +1,61 @@
-/*
- * Copyright (c) 2018 Rafael da Silva Rocha.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-/**
- * @fileoverview Functions to serialize and deserialize UTF-8 strings.
- * @see https://github.com/rochars/utf8-buffer
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- */
-/** @module utf8-buffer */
-/**
- * Read a string of UTF-8 characters from a byte buffer.
- * Invalid characters are replaced with 'REPLACEMENT CHARACTER' (U+FFFD).
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://stackoverflow.com/a/34926911
- * @param {!Uint8Array|!Array<number>} buffer A byte buffer.
- * @param {number=} start The buffer index to start reading.
- * @param {?number=} end The buffer index to stop reading.
- *   Assumes the buffer length if undefined.
- * @return {string}
- */
 export function unpack(buffer, start = 0, end = buffer.length) {
-    /** @type {string} */
-    let str = "";
-    for (let index = start; index < end;) {
-        /** @type {number} */
-        let lowerBoundary = 0x80;
-        /** @type {number} */
-        let upperBoundary = 0xbf;
-        /** @type {boolean} */
-        let replace = false;
-        /** @type {number} */
-        let charCode = buffer[index++];
-        if (charCode >= 0x00 && charCode <= 0x7f) {
-            str += String.fromCharCode(charCode);
+    const len = end - start;
+    if (len < 1)
+        return "";
+    const chunks = [];
+    const chunk = [];
+    let i = 0;
+    while (start < end) {
+        let t = buffer[start++];
+        if (t < 128) {
+            chunk[i++] = t;
+        }
+        else if (t > 191 && t < 224) {
+            chunk[i++] = ((t & 31) << 6) | (buffer[start++] & 63);
+        }
+        else if (t > 239 && t < 245) {
+            t =
+                (((t & 7) << 18) | ((buffer[start++] & 63) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63)) -
+                    0x10000;
+            chunk[i++] = 0xd800 + (t >> 10);
+            chunk[i++] = 0xdc00 + (t & 1023);
         }
         else {
-            /** @type {number} */
-            let count = 0;
-            if (charCode >= 0xc2 && charCode <= 0xdf) {
-                count = 1;
-            }
-            else if (charCode >= 0xe0 && charCode <= 0xef) {
-                count = 2;
-                if (buffer[index] === 0xe0) {
-                    lowerBoundary = 0xa0;
-                }
-                if (buffer[index] === 0xed) {
-                    upperBoundary = 0x9f;
-                }
-            }
-            else if (charCode >= 0xf0 && charCode <= 0xf4) {
-                count = 3;
-                if (buffer[index] === 0xf0) {
-                    lowerBoundary = 0x90;
-                }
-                if (buffer[index] === 0xf4) {
-                    upperBoundary = 0x8f;
-                }
-            }
-            else {
-                replace = true;
-            }
-            charCode = charCode & ((1 << (8 - count - 1)) - 1);
-            for (let i = 0; i < count; i++) {
-                if (buffer[index] < lowerBoundary || buffer[index] > upperBoundary) {
-                    replace = true;
-                }
-                charCode = (charCode << 6) | (buffer[index] & 0x3f);
-                index++;
-            }
-            if (replace) {
-                str += String.fromCharCode(0xfffd);
-            }
-            else if (charCode <= 0xffff) {
-                str += String.fromCharCode(charCode);
-            }
-            else {
-                charCode -= 0x10000;
-                str += String.fromCharCode(((charCode >> 10) & 0x3ff) + 0xd800, (charCode & 0x3ff) + 0xdc00);
-            }
+            chunk[i++] = ((t & 15) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63);
+        }
+        if (i > 8191) {
+            chunks.push(String.fromCharCode.apply(String, chunk));
+            i = 0;
         }
     }
-    return str;
+    if (i > 0) {
+        chunks.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+    }
+    return chunks.join("");
 }
-/**
- * Write a string of UTF-8 characters to a byte buffer.
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- * @param {string} str The string to pack.
- * @param {!Uint8Array|!Array<number>} buffer The buffer to pack the string to.
- * @param {number=} index The buffer index to start writing.
- * @return {number} The next index to write in the buffer.
- */
 export function pack(str, buffer, index = 0) {
-    for (let i = 0, len = str.length; i < len; i++) {
-        /** @type {number} */
-        let codePoint = str.codePointAt(i);
-        if (codePoint < 128) {
-            buffer[index] = codePoint;
-            index++;
+    let c1, c2;
+    for (let i = 0; i < str.length; i++) {
+        c1 = str.charCodeAt(i);
+        if (c1 < 128) {
+            buffer[index++] = c1;
+        }
+        else if (c1 < 2048) {
+            buffer[index++] = (c1 >> 6) | 192;
+            buffer[index++] = (c1 & 63) | 128;
+        }
+        else if ((c1 & 0xfc00) === 0xd800 && ((c2 = str.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+            c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+            i++;
+            buffer[index++] = (c1 >> 18) | 240;
+            buffer[index++] = ((c1 >> 12) & 63) | 128;
+            buffer[index++] = ((c1 >> 6) & 63) | 128;
+            buffer[index++] = (c1 & 63) | 128;
         }
         else {
-            /** @type {number} */
-            let count = 0;
-            /** @type {number} */
-            let offset = 0;
-            if (codePoint <= 0x07ff) {
-                count = 1;
-                offset = 0xc0;
-            }
-            else if (codePoint <= 0xffff) {
-                count = 2;
-                offset = 0xe0;
-            }
-            else if (codePoint <= 0x10ffff) {
-                count = 3;
-                offset = 0xf0;
-                i++;
-            }
-            buffer[index] = (codePoint >> (6 * count)) + offset;
-            index++;
-            while (count > 0) {
-                buffer[index] = 0x80 | ((codePoint >> (6 * (count - 1))) & 0x3f);
-                index++;
-                count--;
-            }
+            buffer[index++] = (c1 >> 12) | 224;
+            buffer[index++] = ((c1 >> 6) & 63) | 128;
+            buffer[index++] = (c1 & 63) | 128;
         }
     }
     return index;

package/package.json

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

package/tsconfig.json

@@ -4,7 +4,6 @@
     "module": "esnext",
     "moduleResolution": "node",
     "declaration": true,
-    "allowJs": true,
     "outDir": "./lib",
     "strict": true
   }

package/utf8-buffer.ts

@@ -0,0 +1,59 @@
+export function unpack(buffer: Uint8Array, start = 0, end = buffer.length): string {
+  const len = end - start;
+  if (len < 1) return "";
+
+  const chunks: string[] = [];
+  const chunk: number[] = [];
+  let i = 0;
+
+  while (start < end) {
+    let t = buffer[start++];
+    if (t < 128) {
+      chunk[i++] = t;
+    } else if (t > 191 && t < 224) {
+      chunk[i++] = ((t & 31) << 6) | (buffer[start++] & 63);
+    } else if (t > 239 && t < 245) {
+      t =
+        (((t & 7) << 18) | ((buffer[start++] & 63) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63)) -
+        0x10000;
+      chunk[i++] = 0xd800 + (t >> 10);
+      chunk[i++] = 0xdc00 + (t & 1023);
+    } else {
+      chunk[i++] = ((t & 15) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63);
+    }
+    if (i > 8191) {
+      chunks.push(String.fromCharCode.apply(String, chunk));
+      i = 0;
+    }
+  }
+
+  if (i > 0) {
+    chunks.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+  }
+  return chunks.join("");
+}
+
+export function pack(str: string, buffer: Uint8Array, index = 0): number {
+  let c1: number, c2: number;
+  for (let i = 0; i < str.length; i++) {
+    c1 = str.charCodeAt(i);
+    if (c1 < 128) {
+      buffer[index++] = c1;
+    } else if (c1 < 2048) {
+      buffer[index++] = (c1 >> 6) | 192;
+      buffer[index++] = (c1 & 63) | 128;
+    } else if ((c1 & 0xfc00) === 0xd800 && ((c2 = str.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+      c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+      i++;
+      buffer[index++] = (c1 >> 18) | 240;
+      buffer[index++] = ((c1 >> 12) & 63) | 128;
+      buffer[index++] = ((c1 >> 6) & 63) | 128;
+      buffer[index++] = (c1 & 63) | 128;
+    } else {
+      buffer[index++] = (c1 >> 12) | 224;
+      buffer[index++] = ((c1 >> 6) & 63) | 128;
+      buffer[index++] = (c1 & 63) | 128;
+    }
+  }
+  return index;
+}

package/utf8-buffer.d.ts

@@ -1,27 +0,0 @@
-// Type definitions for utf8-buffer 1.0.0
-// Project: https://github.com/rochars/byte-data
-// Definitions by: Rafael da Silva Rocha <https://github.com/rochars>
-// Definitions: https://github.com/rochars/utf8-buffer
-
-/**
- * Read a string of UTF-8 characters from a byte buffer.
- * Invalid characters are replaced with 'REPLACEMENT CHARACTER' (U+FFFD).
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://stackoverflow.com/a/34926911
- * @param {!Uint8Array|!Array<number>} buffer A byte buffer.
- * @param {number=} start The buffer index to start reading.
- * @param {?number=} end The buffer index to stop reading.
- *   Assumes the buffer length if undefined.
- * @return {string}
- */
-export function unpack(buffer: Uint8Array | number[], start: number, end?: number): string;
-
-/**
- * Write a string of UTF-8 characters to a byte buffer.
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- * @param {string} str The string to pack.
- * @param {!Uint8Array|!Array<number>} buffer The buffer to pack the string to.
- * @param {number=} index The buffer index to start writing.
- * @return {number} The next index to write in the buffer.
- */
-export function pack(str: string, buffer: Uint8Array | number[], index?: number): number;

package/utf8-buffer.js

@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2018 Rafael da Silva Rocha.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-/**
- * @fileoverview Functions to serialize and deserialize UTF-8 strings.
- * @see https://github.com/rochars/utf8-buffer
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- */
-
-/** @module utf8-buffer */
-
-/**
- * Read a string of UTF-8 characters from a byte buffer.
- * Invalid characters are replaced with 'REPLACEMENT CHARACTER' (U+FFFD).
- * @see https://encoding.spec.whatwg.org/#the-encoding
- * @see https://stackoverflow.com/a/34926911
- * @param {!Uint8Array|!Array<number>} buffer A byte buffer.
- * @param {number=} start The buffer index to start reading.
- * @param {?number=} end The buffer index to stop reading.
- *   Assumes the buffer length if undefined.
- * @return {string}
- */
-export function unpack(buffer, start = 0, end = buffer.length) {
-  /** @type {string} */
-  let str = "";
-  for (let index = start; index < end; ) {
-    /** @type {number} */
-    let lowerBoundary = 0x80;
-    /** @type {number} */
-    let upperBoundary = 0xbf;
-    /** @type {boolean} */
-    let replace = false;
-    /** @type {number} */
-    let charCode = buffer[index++];
-    if (charCode >= 0x00 && charCode <= 0x7f) {
-      str += String.fromCharCode(charCode);
-    } else {
-      /** @type {number} */
-      let count = 0;
-      if (charCode >= 0xc2 && charCode <= 0xdf) {
-        count = 1;
-      } else if (charCode >= 0xe0 && charCode <= 0xef) {
-        count = 2;
-        if (buffer[index] === 0xe0) {
-          lowerBoundary = 0xa0;
-        }
-        if (buffer[index] === 0xed) {
-          upperBoundary = 0x9f;
-        }
-      } else if (charCode >= 0xf0 && charCode <= 0xf4) {
-        count = 3;
-        if (buffer[index] === 0xf0) {
-          lowerBoundary = 0x90;
-        }
-        if (buffer[index] === 0xf4) {
-          upperBoundary = 0x8f;
-        }
-      } else {
-        replace = true;
-      }
-      charCode = charCode & ((1 << (8 - count - 1)) - 1);
-      for (let i = 0; i < count; i++) {
-        if (buffer[index] < lowerBoundary || buffer[index] > upperBoundary) {
-          replace = true;
-        }
-        charCode = (charCode << 6) | (buffer[index] & 0x3f);
-        index++;
-      }
-      if (replace) {
-        str += String.fromCharCode(0xfffd);
-      } else if (charCode <= 0xffff) {
-        str += String.fromCharCode(charCode);
-      } else {
-        charCode -= 0x10000;
-        str += String.fromCharCode(((charCode >> 10) & 0x3ff) + 0xd800, (charCode & 0x3ff) + 0xdc00);
-      }
-    }
-  }
-  return str;
-}
-
-/**
- * Write a string of UTF-8 characters to a byte buffer.
- * @see https://encoding.spec.whatwg.org/#utf-8-encoder
- * @param {string} str The string to pack.
- * @param {!Uint8Array|!Array<number>} buffer The buffer to pack the string to.
- * @param {number=} index The buffer index to start writing.
- * @return {number} The next index to write in the buffer.
- */
-export function pack(str, buffer, index = 0) {
-  for (let i = 0, len = str.length; i < len; i++) {
-    /** @type {number} */
-    let codePoint = str.codePointAt(i);
-    if (codePoint < 128) {
-      buffer[index] = codePoint;
-      index++;
-    } else {
-      /** @type {number} */
-      let count = 0;
-      /** @type {number} */
-      let offset = 0;
-      if (codePoint <= 0x07ff) {
-        count = 1;
-        offset = 0xc0;
-      } else if (codePoint <= 0xffff) {
-        count = 2;
-        offset = 0xe0;
-      } else if (codePoint <= 0x10ffff) {
-        count = 3;
-        offset = 0xf0;
-        i++;
-      }
-      buffer[index] = (codePoint >> (6 * count)) + offset;
-      index++;
-      while (count > 0) {
-        buffer[index] = 0x80 | ((codePoint >> (6 * (count - 1))) & 0x3f);
-        index++;
-        count--;
-      }
-    }
-  }
-  return index;
-}