bson 6.3.0 → 6.4.1

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,8 +25,6 @@ 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, 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 */
@@ -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

@@ -13,7 +13,11 @@
  * @param end - The index to stop searching the uint8array
  * @returns string if all bytes are within the basic latin range, otherwise null
  */
-export function tryLatin(uint8array: Uint8Array, start: number, end: number): string | null {
+export function tryReadBasicLatin(
+  uint8array: Uint8Array,
+  start: number,
+  end: number
+): string | null {
   if (uint8array.length === 0) {
     return '';
   }
@@ -59,3 +63,42 @@ export function tryLatin(uint8array: Uint8Array, start: number, end: number): st
 
   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,6 +1,6 @@
 import { BSONError } from '../error';
 import { validateUtf8 } from '../validate_utf8';
-import { tryLatin } from './latin';
+import { tryReadBasicLatin, tryWriteBasicLatin } from './latin';
 
 type NodeJsEncoding = 'base64' | 'hex' | 'utf8' | 'binary';
 type NodeJsBuffer = ArrayBufferView &
@@ -12,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;
@@ -89,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);
   },
@@ -123,12 +128,8 @@ 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 ? tryLatin(buffer, start, end) : null;
+    const basicLatin = end - start <= 20 ? tryReadBasicLatin(buffer, start, end) : null;
     if (basicLatin != null) {
       return basicLatin;
     }
@@ -153,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,174 @@
+const FLOAT = new Float64Array(1);
+const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+
+FLOAT[0] = -1;
+// Little endian [0, 0, 0, 0, 0, 0,  240, 191]
+// Big endian    [191, 240, 0, 0, 0, 0, 0, 0]
+const isBigEndian = FLOAT_BYTES[7] === 0;
+
+/**
+ * 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 {
+    // eslint-disable-next-line no-restricted-globals
+    const hi = BigInt(
+      source[offset + 4] +
+        source[offset + 5] * 256 +
+        source[offset + 6] * 65536 +
+        (source[offset + 7] << 24)
+    ); // Overflow
+
+    // eslint-disable-next-line no-restricted-globals
+    const lo = BigInt(
+      source[offset] +
+        source[offset + 1] * 256 +
+        source[offset + 2] * 65536 +
+        source[offset + 3] * 16777216
+    );
+    // eslint-disable-next-line no-restricted-globals
+    return (hi << BigInt(32)) + lo;
+  },
+
+  /** Reads a little-endian 64-bit float from source */
+  getFloat64LE: isBigEndian
+    ? (source: Uint8Array, offset: number) => {
+        FLOAT_BYTES[7] = source[offset];
+        FLOAT_BYTES[6] = source[offset + 1];
+        FLOAT_BYTES[5] = source[offset + 2];
+        FLOAT_BYTES[4] = source[offset + 3];
+        FLOAT_BYTES[3] = source[offset + 4];
+        FLOAT_BYTES[2] = source[offset + 5];
+        FLOAT_BYTES[1] = source[offset + 6];
+        FLOAT_BYTES[0] = source[offset + 7];
+        return FLOAT[0];
+      }
+    : (source: Uint8Array, offset: 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: isBigEndian
+    ? (destination: Uint8Array, offset: number, value: number) => {
+        FLOAT[0] = value;
+        destination[offset] = FLOAT_BYTES[7];
+        destination[offset + 1] = FLOAT_BYTES[6];
+        destination[offset + 2] = FLOAT_BYTES[5];
+        destination[offset + 3] = FLOAT_BYTES[4];
+        destination[offset + 4] = FLOAT_BYTES[3];
+        destination[offset + 5] = FLOAT_BYTES[2];
+        destination[offset + 6] = FLOAT_BYTES[1];
+        destination[offset + 7] = FLOAT_BYTES[0];
+        return 8;
+      }
+    : (destination: Uint8Array, offset: number, value: number) => {
+        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;
+      }
+};

package/src/utils/web_byte_utils.ts

@@ -1,5 +1,5 @@
 import { BSONError } from '../error';
-import { tryLatin } from './latin';
+import { tryReadBasicLatin } from './latin';
 
 type TextDecoder = {
   readonly encoding: string;
@@ -109,6 +109,10 @@ export const webByteUtils = {
     return new Uint8Array(size);
   },
 
+  allocateUnsafe(size: number): Uint8Array {
+    return webByteUtils.allocate(size);
+  },
+
   equals(a: Uint8Array, b: Uint8Array): boolean {
     if (a.byteLength !== b.byteLength) {
       return false;
@@ -169,12 +173,8 @@ export const webByteUtils = {
     return Array.from(uint8array, byte => byte.toString(16).padStart(2, '0')).join('');
   },
 
-  fromUTF8(text: string): Uint8Array {
-    return new TextEncoder().encode(text);
-  },
-
   toUTF8(uint8array: Uint8Array, start: number, end: number, fatal: boolean): string {
-    const basicLatin = end - start <= 20 ? tryLatin(uint8array, start, end) : null;
+    const basicLatin = end - start <= 20 ? tryReadBasicLatin(uint8array, start, end) : null;
     if (basicLatin != null) {
       return basicLatin;
     }
@@ -190,12 +190,12 @@ export const webByteUtils = {
   },
 
   utf8ByteLength(input: string): number {
-    return webByteUtils.fromUTF8(input).byteLength;
+    return new TextEncoder().encode(input).byteLength;
   },
 
-  encodeUTF8Into(buffer: Uint8Array, source: string, byteOffset: number): number {
-    const bytes = webByteUtils.fromUTF8(source);
-    buffer.set(bytes, byteOffset);
+  encodeUTF8Into(uint8array: Uint8Array, source: string, byteOffset: number): number {
+    const bytes = new TextEncoder().encode(source);
+    uint8array.set(bytes, byteOffset);
     return bytes.byteLength;
   },