bson 6.2.0 → 6.4.0

package/src/parser/serializer.ts

@@ -12,6 +12,7 @@ import type { MinKey } from '../min_key';
 import type { ObjectId } from '../objectid';
 import type { BSONRegExp } from '../regexp';
 import { ByteUtils } from '../utils/byte_utils';
+import { NumberUtils } from '../utils/number_utils';
 import { isAnyArrayBuffer, isDate, isMap, isRegExp, isUint8Array } from './utils';
 
 /** @public */
@@ -61,10 +62,7 @@ function serializeString(buffer: Uint8Array, key: string, value: string, index:
   // Write the string
   const size = ByteUtils.encodeUTF8Into(buffer, value, index + 4);
   // Write the size of the string to buffer
-  buffer[index + 3] = ((size + 1) >> 24) & 0xff;
-  buffer[index + 2] = ((size + 1) >> 16) & 0xff;
-  buffer[index + 1] = ((size + 1) >> 8) & 0xff;
-  buffer[index] = (size + 1) & 0xff;
+  NumberUtils.setInt32LE(buffer, index, size + 1);
   // Update index
   index = index + 4 + size;
   // Write zero
@@ -72,10 +70,6 @@ function serializeString(buffer: Uint8Array, key: string, value: string, index:
   return index;
 }
 
-const NUMBER_SPACE = new DataView(new ArrayBuffer(8), 0, 8);
-const FOUR_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 4);
-const EIGHT_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 8);
-
 function serializeNumber(buffer: Uint8Array, key: string, value: number, index: number) {
   const isNegativeZero = Object.is(value, -0);
 
@@ -87,23 +81,17 @@ function serializeNumber(buffer: Uint8Array, key: string, value: number, index:
       ? constants.BSON_DATA_INT
       : constants.BSON_DATA_NUMBER;
 
-  if (type === constants.BSON_DATA_INT) {
-    NUMBER_SPACE.setInt32(0, value, true);
-  } else {
-    NUMBER_SPACE.setFloat64(0, value, true);
-  }
-
-  const bytes =
-    type === constants.BSON_DATA_INT ? FOUR_BYTE_VIEW_ON_NUMBER : EIGHT_BYTE_VIEW_ON_NUMBER;
-
   buffer[index++] = type;
 
   const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0x00;
 
-  buffer.set(bytes, index);
-  index += bytes.byteLength;
+  if (type === constants.BSON_DATA_INT) {
+    index += NumberUtils.setInt32LE(buffer, index, value);
+  } else {
+    index += NumberUtils.setFloat64LE(buffer, index, value);
+  }
 
   return index;
 }
@@ -115,10 +103,9 @@ function serializeBigInt(buffer: Uint8Array, key: string, value: bigint, index:
   // Encode the name
   index += numberOfWrittenBytes;
   buffer[index++] = 0;
-  NUMBER_SPACE.setBigInt64(0, value, true);
-  // Write BigInt value
-  buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
-  index += EIGHT_BYTE_VIEW_ON_NUMBER.byteLength;
+
+  index += NumberUtils.setBigInt64LE(buffer, index, value);
+
   return index;
 }
 
@@ -162,15 +149,9 @@ function serializeDate(buffer: Uint8Array, key: string, value: Date, index: numb
   const lowBits = dateInMilis.getLowBits();
   const highBits = dateInMilis.getHighBits();
   // Encode low bits
-  buffer[index++] = lowBits & 0xff;
-  buffer[index++] = (lowBits >> 8) & 0xff;
-  buffer[index++] = (lowBits >> 16) & 0xff;
-  buffer[index++] = (lowBits >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, lowBits);
   // Encode high bits
-  buffer[index++] = highBits & 0xff;
-  buffer[index++] = (highBits >> 8) & 0xff;
-  buffer[index++] = (highBits >> 16) & 0xff;
-  buffer[index++] = (highBits >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, highBits);
   return index;
 }
 
@@ -256,16 +237,7 @@ function serializeObjectId(buffer: Uint8Array, key: string, value: ObjectId, ind
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
 
-  // Write the objectId into the shared buffer
-  const idValue = value.id;
-
-  if (isUint8Array(idValue)) {
-    for (let i = 0; i < 12; i++) {
-      buffer[index++] = idValue[i];
-    }
-  } else {
-    throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
-  }
+  index += value.serializeInto(buffer, index);
 
   // Adjust index
   return index;
@@ -282,14 +254,15 @@ function serializeBuffer(buffer: Uint8Array, key: string, value: Uint8Array, ind
   // Get size of the buffer (current write point)
   const size = value.length;
   // Write the size of the string to buffer
-  buffer[index++] = size & 0xff;
-  buffer[index++] = (size >> 8) & 0xff;
-  buffer[index++] = (size >> 16) & 0xff;
-  buffer[index++] = (size >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, size);
   // Write the default subtype
   buffer[index++] = constants.BSON_BINARY_SUBTYPE_DEFAULT;
   // Copy the content form the binary field to the buffer
-  buffer.set(value, index);
+  if (size <= 16) {
+    for (let i = 0; i < size; i++) buffer[index + i] = value[i];
+  } else {
+    buffer.set(value, index);
+  }
   // Adjust the index
   index = index + size;
   return index;
@@ -343,7 +316,7 @@ function serializeDecimal128(buffer: Uint8Array, key: string, value: Decimal128,
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   // Write the data from the value
-  buffer.set(value.bytes.subarray(0, 16), index);
+  for (let i = 0; i < 16; i++) buffer[index + i] = value.bytes[i];
   return index + 16;
 }
 
@@ -360,15 +333,9 @@ function serializeLong(buffer: Uint8Array, key: string, value: Long, index: numb
   const lowBits = value.getLowBits();
   const highBits = value.getHighBits();
   // Encode low bits
-  buffer[index++] = lowBits & 0xff;
-  buffer[index++] = (lowBits >> 8) & 0xff;
-  buffer[index++] = (lowBits >> 16) & 0xff;
-  buffer[index++] = (lowBits >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, lowBits);
   // Encode high bits
-  buffer[index++] = highBits & 0xff;
-  buffer[index++] = (highBits >> 8) & 0xff;
-  buffer[index++] = (highBits >> 16) & 0xff;
-  buffer[index++] = (highBits >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, highBits);
   return index;
 }
 
@@ -382,10 +349,7 @@ function serializeInt32(buffer: Uint8Array, key: string, value: Int32 | number,
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   // Write the int value
-  buffer[index++] = value & 0xff;
-  buffer[index++] = (value >> 8) & 0xff;
-  buffer[index++] = (value >> 16) & 0xff;
-  buffer[index++] = (value >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, value);
   return index;
 }
 
@@ -401,11 +365,8 @@ function serializeDouble(buffer: Uint8Array, key: string, value: Double, index:
   buffer[index++] = 0;
 
   // Write float
-  NUMBER_SPACE.setFloat64(0, value.value, true);
-  buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
+  index += NumberUtils.setFloat64LE(buffer, index, value.value);
 
-  // Adjust index
-  index = index + 8;
   return index;
 }
 
@@ -422,10 +383,7 @@ function serializeFunction(buffer: Uint8Array, key: string, value: Function, ind
   // Write the string
   const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
   // Write the size of the string to buffer
-  buffer[index] = size & 0xff;
-  buffer[index + 1] = (size >> 8) & 0xff;
-  buffer[index + 2] = (size >> 16) & 0xff;
-  buffer[index + 3] = (size >> 24) & 0xff;
+  NumberUtils.setInt32LE(buffer, index, size);
   // Update index
   index = index + 4 + size - 1;
   // Write zero
@@ -464,10 +422,7 @@ function serializeCode(
     // Write string into buffer
     const codeSize = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
     // Write the size of the string to buffer
-    buffer[index] = codeSize & 0xff;
-    buffer[index + 1] = (codeSize >> 8) & 0xff;
-    buffer[index + 2] = (codeSize >> 16) & 0xff;
-    buffer[index + 3] = (codeSize >> 24) & 0xff;
+    NumberUtils.setInt32LE(buffer, index, codeSize);
     // Write end 0
     buffer[index + 4 + codeSize - 1] = 0;
     // Write the
@@ -490,10 +445,7 @@ function serializeCode(
     const totalSize = endIndex - startIndex;
 
     // Write the total size of the object
-    buffer[startIndex++] = totalSize & 0xff;
-    buffer[startIndex++] = (totalSize >> 8) & 0xff;
-    buffer[startIndex++] = (totalSize >> 16) & 0xff;
-    buffer[startIndex++] = (totalSize >> 24) & 0xff;
+    startIndex += NumberUtils.setInt32LE(buffer, startIndex, totalSize);
     // Write trailing zero
     buffer[index++] = 0;
   } else {
@@ -508,10 +460,7 @@ function serializeCode(
     // Write the string
     const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
     // Write the size of the string to buffer
-    buffer[index] = size & 0xff;
-    buffer[index + 1] = (size >> 8) & 0xff;
-    buffer[index + 2] = (size >> 16) & 0xff;
-    buffer[index + 3] = (size >> 24) & 0xff;
+    NumberUtils.setInt32LE(buffer, index, size);
     // Update index
     index = index + 4 + size - 1;
     // Write zero
@@ -536,24 +485,21 @@ function serializeBinary(buffer: Uint8Array, key: string, value: Binary, index:
   // Add the deprecated 02 type 4 bytes of size to total
   if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) size = size + 4;
   // Write the size of the string to buffer
-  buffer[index++] = size & 0xff;
-  buffer[index++] = (size >> 8) & 0xff;
-  buffer[index++] = (size >> 16) & 0xff;
-  buffer[index++] = (size >> 24) & 0xff;
+  index += NumberUtils.setInt32LE(buffer, index, size);
   // Write the subtype to the buffer
   buffer[index++] = value.sub_type;
 
   // If we have binary type 2 the 4 first bytes are the size
   if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
     size = size - 4;
-    buffer[index++] = size & 0xff;
-    buffer[index++] = (size >> 8) & 0xff;
-    buffer[index++] = (size >> 16) & 0xff;
-    buffer[index++] = (size >> 24) & 0xff;
+    index += NumberUtils.setInt32LE(buffer, index, size);
   }
 
-  // Write the data to the object
-  buffer.set(data, index);
+  if (size <= 16) {
+    for (let i = 0; i < size; i++) buffer[index + i] = data[i];
+  } else {
+    buffer.set(data, index);
+  }
   // Adjust the index
   index = index + value.position;
   return index;
@@ -570,14 +516,11 @@ function serializeSymbol(buffer: Uint8Array, key: string, value: BSONSymbol, ind
   // Write the string
   const size = ByteUtils.encodeUTF8Into(buffer, value.value, index + 4) + 1;
   // Write the size of the string to buffer
-  buffer[index] = size & 0xff;
-  buffer[index + 1] = (size >> 8) & 0xff;
-  buffer[index + 2] = (size >> 16) & 0xff;
-  buffer[index + 3] = (size >> 24) & 0xff;
+  NumberUtils.setInt32LE(buffer, index, size);
   // Update index
   index = index + 4 + size - 1;
   // Write zero
-  buffer[index++] = 0x00;
+  buffer[index++] = 0;
   return index;
 }
 
@@ -624,10 +567,7 @@ function serializeDBRef(
   // Calculate object size
   const size = endIndex - startIndex;
   // Write the size
-  buffer[startIndex++] = size & 0xff;
-  buffer[startIndex++] = (size >> 8) & 0xff;
-  buffer[startIndex++] = (size >> 16) & 0xff;
-  buffer[startIndex++] = (size >> 24) & 0xff;
+  startIndex += NumberUtils.setInt32LE(buffer, index, size);
   // Set index
   return endIndex;
 }
@@ -799,7 +739,7 @@ export function serializeInto(
         if (checkKeys) {
           if ('$' === key[0]) {
             throw new BSONError('key ' + key + " must not start with '$'");
-          } else if (~key.indexOf('.')) {
+          } else if (key.includes('.')) {
             throw new BSONError('key ' + key + " must not contain '.'");
           }
         }
@@ -907,7 +847,7 @@ export function serializeInto(
         if (checkKeys) {
           if ('$' === key[0]) {
             throw new BSONError('key ' + key + " must not start with '$'");
-          } else if (~key.indexOf('.')) {
+          } else if (key.includes('.')) {
             throw new BSONError('key ' + key + " must not contain '.'");
           }
         }
@@ -997,9 +937,6 @@ export function serializeInto(
   // Final size
   const size = index - startingIndex;
   // Write the size of the object
-  buffer[startingIndex++] = size & 0xff;
-  buffer[startingIndex++] = (size >> 8) & 0xff;
-  buffer[startingIndex++] = (size >> 16) & 0xff;
-  buffer[startingIndex++] = (size >> 24) & 0xff;
+  startingIndex += NumberUtils.setInt32LE(buffer, startingIndex, size);
   return index;
 }

package/src/utils/byte_utils.ts

@@ -7,6 +7,8 @@ export type ByteUtils = {
   toLocalBufferType(buffer: Uint8Array | ArrayBufferView | ArrayBuffer): Uint8Array;
   /** Create empty space of size */
   allocate: (size: number) => Uint8Array;
+  /** Create empty space of size, use pooled memory when available */
+  allocateUnsafe: (size: number) => Uint8Array;
   /** Check if two Uint8Arrays are deep equal */
   equals: (a: Uint8Array, b: Uint8Array) => boolean;
   /** Check if two Uint8Arrays are deep equal */
@@ -23,10 +25,8 @@ export type ByteUtils = {
   fromHex: (hex: string) => Uint8Array;
   /** Create a lowercase hex string from bytes */
   toHex: (buffer: Uint8Array) => string;
-  /** Create a Uint8Array containing utf8 code units from a string */
-  fromUTF8: (text: string) => Uint8Array;
-  /** Create a string from utf8 code units */
-  toUTF8: (buffer: Uint8Array, start: number, end: number) => string;
+  /** Create a string from utf8 code units, fatal=true will throw an error if UTF-8 bytes are invalid, fatal=false will insert replacement characters */
+  toUTF8: (buffer: Uint8Array, start: number, end: number, fatal: boolean) => string;
   /** Get the utf8 code unit count from a string if it were to be transformed to utf8 */
   utf8ByteLength: (input: string) => number;
   /** Encode UTF8 bytes generated from `source` string into `destination` at byteOffset. Returns the number of bytes encoded. */
@@ -53,9 +53,3 @@ const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuf
  * @internal
  */
 export const ByteUtils: ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
-
-export class BSONDataView extends DataView {
-  static fromUint8Array(input: Uint8Array) {
-    return new DataView(input.buffer, input.byteOffset, input.byteLength);
-  }
-}

package/src/utils/latin.ts

@@ -0,0 +1,104 @@
+/**
+ * This function is an optimization for small basic latin strings.
+ * @internal
+ * @remarks
+ * ### Important characteristics:
+ * - If the uint8array or distance between start and end is 0 this function returns an empty string
+ * - If the byteLength of the string is 1, 2, or 3 we invoke String.fromCharCode and manually offset into the buffer
+ * - If the byteLength of the string is less than or equal to 20 an array of bytes is built and `String.fromCharCode.apply` is called with the result
+ * - If any byte exceeds 128 this function returns null
+ *
+ * @param uint8array - A sequence of bytes that may contain basic latin characters
+ * @param start - The start index from which to search the uint8array
+ * @param end - The index to stop searching the uint8array
+ * @returns string if all bytes are within the basic latin range, otherwise null
+ */
+export function tryReadBasicLatin(
+  uint8array: Uint8Array,
+  start: number,
+  end: number
+): string | null {
+  if (uint8array.length === 0) {
+    return '';
+  }
+
+  const stringByteLength = end - start;
+  if (stringByteLength === 0) {
+    return '';
+  }
+
+  if (stringByteLength > 20) {
+    return null;
+  }
+
+  if (stringByteLength === 1 && uint8array[start] < 128) {
+    return String.fromCharCode(uint8array[start]);
+  }
+
+  if (stringByteLength === 2 && uint8array[start] < 128 && uint8array[start + 1] < 128) {
+    return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]);
+  }
+
+  if (
+    stringByteLength === 3 &&
+    uint8array[start] < 128 &&
+    uint8array[start + 1] < 128 &&
+    uint8array[start + 2] < 128
+  ) {
+    return (
+      String.fromCharCode(uint8array[start]) +
+      String.fromCharCode(uint8array[start + 1]) +
+      String.fromCharCode(uint8array[start + 2])
+    );
+  }
+
+  const latinBytes = [];
+  for (let i = start; i < end; i++) {
+    const byte = uint8array[i];
+    if (byte > 127) {
+      return null;
+    }
+    latinBytes.push(byte);
+  }
+
+  return String.fromCharCode(...latinBytes);
+}
+
+/**
+ * This function is an optimization for writing small basic latin strings.
+ * @internal
+ * @remarks
+ * ### Important characteristics:
+ * - If the string length is 0 return 0, do not perform any work
+ * - If a string is longer than 25 code units return null
+ * - If any code unit exceeds 128 this function returns null
+ *
+ * @param destination - The uint8array to serialize the string to
+ * @param source - The string to turn into UTF-8 bytes if it fits in the basic latin range
+ * @param offset - The position in the destination to begin writing bytes to
+ * @returns the number of bytes written to destination if all code units are below 128, otherwise null
+ */
+export function tryWriteBasicLatin(
+  destination: Uint8Array,
+  source: string,
+  offset: number
+): number | null {
+  if (source.length === 0) return 0;
+
+  if (source.length > 25) return null;
+
+  if (destination.length - offset < source.length) return null;
+
+  for (
+    let charOffset = 0, destinationOffset = offset;
+    charOffset < source.length;
+    charOffset++, destinationOffset++
+  ) {
+    const char = source.charCodeAt(charOffset);
+    if (char > 127) return null;
+
+    destination[destinationOffset] = char;
+  }
+
+  return source.length;
+}

package/src/utils/node_byte_utils.ts

@@ -1,4 +1,6 @@
 import { BSONError } from '../error';
+import { validateUtf8 } from '../validate_utf8';
+import { tryReadBasicLatin, tryWriteBasicLatin } from './latin';
 
 type NodeJsEncoding = 'base64' | 'hex' | 'utf8' | 'binary';
 type NodeJsBuffer = ArrayBufferView &
@@ -10,6 +12,7 @@ type NodeJsBuffer = ArrayBufferView &
   };
 type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
   alloc: (size: number) => NodeJsBuffer;
+  allocUnsafe: (size: number) => NodeJsBuffer;
   from(array: number[]): NodeJsBuffer;
   from(array: Uint8Array): NodeJsBuffer;
   from(array: ArrayBuffer): NodeJsBuffer;
@@ -87,6 +90,10 @@ export const nodeJsByteUtils = {
     return Buffer.alloc(size);
   },
 
+  allocateUnsafe(size: number): NodeJsBuffer {
+    return Buffer.allocUnsafe(size);
+  },
+
   equals(a: Uint8Array, b: Uint8Array): boolean {
     return nodeJsByteUtils.toLocalBufferType(a).equals(b);
   },
@@ -121,12 +128,25 @@ export const nodeJsByteUtils = {
     return nodeJsByteUtils.toLocalBufferType(buffer).toString('hex');
   },
 
-  fromUTF8(text: string): NodeJsBuffer {
-    return Buffer.from(text, 'utf8');
-  },
+  toUTF8(buffer: Uint8Array, start: number, end: number, fatal: boolean): string {
+    const basicLatin = end - start <= 20 ? tryReadBasicLatin(buffer, start, end) : null;
+    if (basicLatin != null) {
+      return basicLatin;
+    }
 
-  toUTF8(buffer: Uint8Array, start: number, end: number): string {
-    return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
+    const string = nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
+    if (fatal) {
+      // TODO(NODE-4930): Insufficiently strict BSON UTF8 validation
+      for (let i = 0; i < string.length; i++) {
+        if (string.charCodeAt(i) === 0xfffd) {
+          if (!validateUtf8(buffer, start, end)) {
+            throw new BSONError('Invalid UTF-8 string in BSON document');
+          }
+          break;
+        }
+      }
+    }
+    return string;
   },
 
   utf8ByteLength(input: string): number {
@@ -134,6 +154,11 @@ export const nodeJsByteUtils = {
   },
 
   encodeUTF8Into(buffer: Uint8Array, source: string, byteOffset: number): number {
+    const latinBytesWritten = tryWriteBasicLatin(buffer, source, byteOffset);
+    if (latinBytesWritten != null) {
+      return latinBytesWritten;
+    }
+
     return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');
   },
 

package/src/utils/number_utils.ts

@@ -0,0 +1,135 @@
+const FLOAT = new Float64Array(1);
+const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+
+/**
+ * Number parsing and serializing utilities.
+ *
+ * @internal
+ */
+export const NumberUtils = {
+  /** Reads a little-endian 32-bit integer from source */
+  getInt32LE(source: Uint8Array, offset: number): number {
+    return (
+      source[offset] |
+      (source[offset + 1] << 8) |
+      (source[offset + 2] << 16) |
+      (source[offset + 3] << 24)
+    );
+  },
+
+  /** Reads a little-endian 32-bit unsigned integer from source */
+  getUint32LE(source: Uint8Array, offset: number): number {
+    return (
+      source[offset] +
+      source[offset + 1] * 256 +
+      source[offset + 2] * 65536 +
+      source[offset + 3] * 16777216
+    );
+  },
+
+  /** Reads a big-endian 32-bit integer from source */
+  getUint32BE(source: Uint8Array, offset: number): number {
+    return (
+      source[offset + 3] +
+      source[offset + 2] * 256 +
+      source[offset + 1] * 65536 +
+      source[offset] * 16777216
+    );
+  },
+
+  /** Reads a little-endian 64-bit integer from source */
+  getBigInt64LE(source: Uint8Array, offset: number): bigint {
+    const lo = NumberUtils.getUint32LE(source, offset);
+    const hi = NumberUtils.getUint32LE(source, offset + 4);
+
+    /*
+      eslint-disable-next-line no-restricted-globals
+      -- This is allowed since this helper should not be called unless bigint features are enabled
+     */
+    return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+  },
+
+  /** Reads a little-endian 64-bit float from source */
+  getFloat64LE(source: Uint8Array, offset: number): number {
+    FLOAT_BYTES[0] = source[offset];
+    FLOAT_BYTES[1] = source[offset + 1];
+    FLOAT_BYTES[2] = source[offset + 2];
+    FLOAT_BYTES[3] = source[offset + 3];
+    FLOAT_BYTES[4] = source[offset + 4];
+    FLOAT_BYTES[5] = source[offset + 5];
+    FLOAT_BYTES[6] = source[offset + 6];
+    FLOAT_BYTES[7] = source[offset + 7];
+    return FLOAT[0];
+  },
+
+  /** Writes a big-endian 32-bit integer to destination, can be signed or unsigned */
+  setInt32BE(destination: Uint8Array, offset: number, value: number): 4 {
+    destination[offset + 3] = value;
+    value >>>= 8;
+    destination[offset + 2] = value;
+    value >>>= 8;
+    destination[offset + 1] = value;
+    value >>>= 8;
+    destination[offset] = value;
+    return 4;
+  },
+
+  /** Writes a little-endian 32-bit integer to destination, can be signed or unsigned */
+  setInt32LE(destination: Uint8Array, offset: number, value: number): 4 {
+    destination[offset] = value;
+    value >>>= 8;
+    destination[offset + 1] = value;
+    value >>>= 8;
+    destination[offset + 2] = value;
+    value >>>= 8;
+    destination[offset + 3] = value;
+    return 4;
+  },
+
+  /** Write a little-endian 64-bit integer to source */
+  setBigInt64LE(destination: Uint8Array, offset: number, value: bigint): 8 {
+    /* eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true */
+    const mask32bits = BigInt(0xffff_ffff);
+
+    /** lower 32 bits */
+    let lo = Number(value & mask32bits);
+    destination[offset] = lo;
+    lo >>= 8;
+    destination[offset + 1] = lo;
+    lo >>= 8;
+    destination[offset + 2] = lo;
+    lo >>= 8;
+    destination[offset + 3] = lo;
+
+    /*
+       eslint-disable-next-line no-restricted-globals
+       -- This is allowed here as useBigInt64=true
+
+       upper 32 bits
+     */
+    let hi = Number((value >> BigInt(32)) & mask32bits);
+    destination[offset + 4] = hi;
+    hi >>= 8;
+    destination[offset + 5] = hi;
+    hi >>= 8;
+    destination[offset + 6] = hi;
+    hi >>= 8;
+    destination[offset + 7] = hi;
+
+    return 8;
+  },
+
+  /** Writes a little-endian 64-bit float to destination */
+  setFloat64LE(destination: Uint8Array, offset: number, value: number): 8 {
+    FLOAT[0] = value;
+    destination[offset] = FLOAT_BYTES[0];
+    destination[offset + 1] = FLOAT_BYTES[1];
+    destination[offset + 2] = FLOAT_BYTES[2];
+    destination[offset + 3] = FLOAT_BYTES[3];
+    destination[offset + 4] = FLOAT_BYTES[4];
+    destination[offset + 5] = FLOAT_BYTES[5];
+    destination[offset + 6] = FLOAT_BYTES[6];
+    destination[offset + 7] = FLOAT_BYTES[7];
+    return 8;
+  }
+};