cleanup

Author: nicknisi

src/common/utils/leb128.ts

@@ -10,16 +10,18 @@
  * - No dependencies on Node.js Buffer or other runtime-specific APIs
  */
 
-const MAX_UINT32 = 0xffffffff; // 4294967295
-const CONTINUATION_BIT = 0x80; // 10000000 in binary
-const DATA_BITS_MASK = 0x7f; // 01111111 in binary
+const MAX_UINT32 = 0xffffffff;
+const CONTINUATION_BIT = 0x80;
+const DATA_BITS_MASK = 0x7f;
+const DATA_BITS_PER_BYTE = 7;
+const MAX_BYTES_FOR_UINT32 = 5; // ceil(32 / 7) = 5
 
 /**
  * Encodes an unsigned 32-bit integer into LEB128 format.
  *
  * @param value - The unsigned 32-bit integer to encode (0 to 4,294,967,295)
  * @returns Uint8Array containing the encoded bytes (1-5 bytes)
- * @throws Error if value is negative, non-integer, NaN, or exceeds MAX_UINT32
+ * @throws Error if value is invalid
  *
  * @example
  * encodeUInt32(0) // Uint8Array[0x00] (1 byte)
@@ -28,43 +30,25 @@ const DATA_BITS_MASK = 0x7f; // 01111111 in binary
  * encodeUInt32(300) // Uint8Array[0xAC, 0x02] (2 bytes)
  */
 export function encodeUInt32(value: number): Uint8Array {
-  // Validate input
-  if (!Number.isFinite(value)) {
-    throw new Error('Value must be a finite number');
-  }
-  if (!Number.isInteger(value)) {
-    throw new Error('Value must be an integer');
-  }
-  if (value < 0) {
-    throw new Error('Value must be non-negative');
-  }
-  if (value > MAX_UINT32) {
-    throw new Error(`Value must not exceed ${MAX_UINT32} (MAX_UINT32)`);
-  }
+  validateUInt32(value);
 
-  // Fast path for zero
+  // Handle zero directly (most common small value)
   if (value === 0) {
     return new Uint8Array([0]);
   }
 
-  // Calculate the maximum number of bytes needed (uint32 needs at most 5 bytes)
   const bytes: number[] = [];
 
-  // Encode the value
-  while (value > 0) {
-    // Extract the lowest 7 bits
+  do {
     let byte = value & DATA_BITS_MASK;
+    value >>>= DATA_BITS_PER_BYTE;
 
-    // Shift right by 7 bits for next iteration
-    value >>>= 7;
-
-    // If there are more bytes to encode, set the continuation bit
-    if (value > 0) {
+    if (value !== 0) {
       byte |= CONTINUATION_BIT;
     }
 
     bytes.push(byte);
-  }
+  } while (value !== 0);
 
   return new Uint8Array(bytes);
 }
@@ -75,7 +59,7 @@ export function encodeUInt32(value: number): Uint8Array {
  * @param data - Uint8Array containing LEB128 encoded data
  * @param offset - Starting position in the buffer (defaults to 0)
  * @returns Object with decoded value and the index after the last byte read
- * @throws Error if offset is out of bounds or encoding is truncated
+ * @throws Error if decoding fails
  *
  * @example
  * decodeUInt32(new Uint8Array([0x00])) // { value: 0, nextIndex: 1 }
@@ -87,38 +71,65 @@ export function decodeUInt32(
   data: Uint8Array,
   offset = 0,
 ): { value: number; nextIndex: number } {
-  // Validate offset
-  if (offset < 0 || offset >= data.length) {
-    throw new Error(`Offset ${offset} is out of bounds (buffer length: ${data.length})`);
-  }
+  validateOffset(data, offset);
 
   let result = 0;
   let shift = 0;
   let index = offset;
+  let bytesRead = 0;
 
-  // Decode bytes until we hit a byte without the continuation bit
   while (index < data.length) {
-    const byte = data[index];
-
-    // Extract the lower 7 bits and shift into position
-    result |= (byte & DATA_BITS_MASK) << shift;
+    const byte = data[index++];
+    bytesRead++;
 
-    index++;
-
-    // If continuation bit is not set, we're done
-    if ((byte & CONTINUATION_BIT) === 0) {
-      return { value: result >>> 0, nextIndex: index }; // >>> 0 ensures unsigned 32-bit
+    // Check for overflow before processing
+    if (bytesRead > MAX_BYTES_FOR_UINT32) {
+      throw new Error('LEB128 sequence exceeds maximum length for uint32');
     }
 
-    // Move to next 7-bit chunk
-    shift += 7;
+    result |= (byte & DATA_BITS_MASK) << shift;
 
-    // Safety check: uint32 should never need more than 5 bytes (5 * 7 = 35 bits)
-    if (shift > 28) {
-      throw new Error('LEB128 sequence exceeds maximum length for uint32');
+    if (!hasContinuationBit(byte)) {
+      // Convert to unsigned 32-bit integer
+      return { value: result >>> 0, nextIndex: index };
     }
+
+    shift += DATA_BITS_PER_BYTE;
   }
 
-  // If we exit the loop, the encoding was truncated
   throw new Error('Truncated LEB128 encoding');
 }
+
+/**
+ * Validates that a value is a valid unsigned 32-bit integer.
+ */
+function validateUInt32(value: number): void {
+  if (!Number.isFinite(value)) {
+    throw new Error('Value must be a finite number');
+  }
+  if (!Number.isInteger(value)) {
+    throw new Error('Value must be an integer');
+  }
+  if (value < 0) {
+    throw new Error('Value must be non-negative');
+  }
+  if (value > MAX_UINT32) {
+    throw new Error(`Value must not exceed ${MAX_UINT32} (MAX_UINT32)`);
+  }
+}
+
+/**
+ * Validates that an offset is within bounds.
+ */
+function validateOffset(data: Uint8Array, offset: number): void {
+  if (offset < 0 || offset >= data.length) {
+    throw new Error(`Offset ${offset} is out of bounds (buffer length: ${data.length})`);
+  }
+}
+
+/**
+ * Checks if a byte has the continuation bit set.
+ */
+function hasContinuationBit(byte: number): boolean {
+  return (byte & CONTINUATION_BIT) !== 0;
+}