v1.9.1 remove per-encode allocations from varint and field iteration

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinybuf",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "author": "Reece Como <reece.como@gmail.com>",
   "authors": [
     "Reece Como <reece.como@gmail.com>",

src/__tests__/coders.test.ts

@@ -259,6 +259,87 @@ describe("coders", () => {
       check(coder, -1 / Infinity);
       check(coder, NaN);
     });
+
+    it("writes little-endian IEEE 754 bytes for special values", () => {
+      [
+        0, -0, NaN, Infinity, -Infinity,
+        Number.MIN_VALUE, -Number.MIN_VALUE, 2.2250738585072009e-308, 2.2250738585072014e-308,
+        Number.MAX_VALUE, Number.EPSILON, Number.MAX_SAFE_INTEGER, Math.PI,
+      ].forEach(value => {
+        const expected = new Uint8Array(8);
+        new DataView(expected.buffer).setFloat64(0, value, true);
+
+        expect(hexBytes(write(coder, value))).toEqual(hexBytes(expected));
+        expect(Object.is(read(coder, write(coder, value)), value)).toBe(true);
+      });
+    });
+  });
+
+  describe("varint byte compatibility", () => {
+    const POW_32 = 0x100000000;
+
+    function legacyUint(value: number): Uint8Array {
+      const dv = new DataView(new ArrayBuffer(8));
+      if (value < 0) value = 0;
+      if (value < 128) dv.setUint8(0, value);
+      else if (value < 16_384) dv.setUint16(0, value + 0x8000);
+      else if (value < 536_870_912) dv.setUint32(0, value + 0xc0000000);
+      else if (value >= 536_870_912) {
+        dv.setUint32(0, Math.floor(value / POW_32) + 0xe0000000);
+        dv.setUint32(4, value >>> 0);
+      }
+      else return new Uint8Array([0]);
+      const len = value < 128 ? 1 : value < 16_384 ? 2 : value < 536_870_912 ? 4 : 8;
+      return new Uint8Array(dv.buffer, 0, len);
+    }
+
+    function legacyInt(value: number): Uint8Array {
+      const dv = new DataView(new ArrayBuffer(8));
+      let len: number;
+      if (value >= -64 && value < 64) {
+        dv.setUint8(0, value & 0x7f); len = 1;
+      }
+      else if (value >= -8_192 && value < 8_192) {
+        dv.setUint16(0, (value & 0x3fff) + 0x8000); len = 2;
+      }
+      else if (value >= -268_435_456 && value < 268_435_456) {
+        dv.setUint32(0, (value & 0x1fffffff) + 0xc0000000); len = 4;
+      }
+      else if (value < -268_435_456 || value >= 268_435_456) {
+        dv.setUint32(0, (Math.floor(value / POW_32) & 0x1fffffff) + 0xe0000000);
+        dv.setUint32(4, value >>> 0);
+        len = 8;
+      }
+      else return new Uint8Array([0]);
+      return new Uint8Array(dv.buffer, 0, len);
+    }
+
+    const values: number[] = [
+      Infinity, -Infinity, Number.MAX_VALUE, Number.MAX_SAFE_INTEGER, -Number.MAX_SAFE_INTEGER,
+      2 ** 61, 2 ** 62 + 12345, 2 ** 32, 2 ** 32 - 1, 2 ** 31, -(2 ** 31), 2 ** 30, -(2 ** 30),
+      Date.UTC(2026, 10, 9), -Date.UTC(2026, 10, 9), 16_384.5, 536_870_911.9, -268_435_456.5,
+    ];
+    for (let e = 0; e <= 62; e++) {
+      const p = 2 ** e;
+      values.push(p - 1, p, p + 1, -p - 1, -p, -p + 1);
+    }
+    for (let i = 0; i < 2000; i++) {
+      values.push(Math.floor((Math.random() - 0.5) * 2 ** (Math.random() * 63)));
+    }
+
+    it("uintCoder writes the same bytes as before", () => {
+      values.forEach(value => {
+        expect(`${value}: ${hexBytes(write(coders.uintCoder, value))}`)
+          .toEqual(`${value}: ${hexBytes(legacyUint(value))}`);
+      });
+    });
+
+    it("intCoder writes the same bytes as before", () => {
+      values.forEach(value => {
+        expect(`${value}: ${hexBytes(write(coders.intCoder, value))}`)
+          .toEqual(`${value}: ${hexBytes(legacyInt(value))}`);
+      });
+    });
   });
 
   describe("uscalar8Coder", () => {

src/core/BufferFormat.ts

@@ -405,7 +405,9 @@ export class BufferFormat<EncoderType extends EncoderDefinition, HeaderType exte
     }
 
     // write each field
-    for (const field of this._$fields) {
+    const fields = this._$fields;
+    for (let i = 0; i < fields.length; i++) {
+      const field = fields[i];
       const subValue = value[field.$name];
 
       if (field.$isOptional) {

src/core/lib/coders.ts

@@ -43,10 +43,11 @@ export const uintCoder: BinaryTypeCoder<number> = {
     if (value < 0) value = 0;
     if (value < MAX_VARUINT8) writer.$writeUint8(value);
     else if (value < MAX_VARUINT16) writer.$writeUint16(value + 0x8000);
-    else if (value < MAX_VARUINT32) writer.$writeUint32(value + 0xc0000000);
+    else if (value < MAX_VARUINT32) writer.$writeUint32((value + 0xc0000000) | 0);
     else if (value >= MAX_VARUINT32) {
-      writer.$writeUint32($floor(value / POW_32) + 0xe0000000);
-      writer.$writeUint32(value >>> 0);
+      writer.$writeUint32(($floor(value / POW_32) + 0xe0000000) | 0);
+      writer.$writeUint16(value >>> 16);
+      writer.$writeUint16(value & 0xffff);
     }
     else {
       // coercion case
@@ -99,11 +100,12 @@ export const intCoder: BinaryTypeCoder<number> = {
     if (typeof value !== "number") value = Number(value);
     if (value >= -MAX_VARINT8 && value < MAX_VARINT8) writer.$writeUint8(value & 0x7f);
     else if (value >= -MAX_VARINT16 && value < MAX_VARINT16) writer.$writeUint16((value & 0x3fff) + 0x8000);
-    else if (value >= -MAX_VARINT32 && value < MAX_VARINT32) writer.$writeUint32((value & 0x1fffffff) + 0xc0000000);
+    else if (value >= -MAX_VARINT32 && value < MAX_VARINT32) writer.$writeUint32((value & 0x1fffffff) | 0xc0000000);
     else if (value < -MAX_VARINT32 || value >= MAX_VARINT32) {
       // Split in two 32b uints
-      writer.$writeUint32(($floor(value / POW_32) & 0x1fffffff) + 0xe0000000);
-      writer.$writeUint32(value >>> 0);
+      writer.$writeUint32(($floor(value / POW_32) & 0x1fffffff) | 0xe0000000);
+      writer.$writeUint16(value >>> 16);
+      writer.$writeUint16(value & 0xffff);
     }
     else {
       // coercion case