bson 4.7.0 → 5.0.0-alpha.0

package/src/parser/serializer.ts

@@ -1,4 +1,3 @@
-import type { Buffer } from 'buffer';
 import { Binary } from '../binary';
 import type { BSONSymbol, DBRef, Document, MaxKey } from '../bson';
 import type { Code } from '../code';
@@ -6,23 +5,21 @@ import * as constants from '../constants';
 import type { DBRefLike } from '../db_ref';
 import type { Decimal128 } from '../decimal128';
 import type { Double } from '../double';
-import { ensureBuffer } from '../ensure_buffer';
 import { BSONError, BSONTypeError } from '../error';
-import { isBSONType } from '../extended_json';
 import type { Int32 } from '../int_32';
 import { Long } from '../long';
-import { Map } from '../map';
 import type { MinKey } from '../min_key';
 import type { ObjectId } from '../objectid';
 import type { BSONRegExp } from '../regexp';
+import { ByteUtils } from '../utils/byte_utils';
 import {
+  isAnyArrayBuffer,
   isBigInt64Array,
   isBigUInt64Array,
   isDate,
   isMap,
   isRegExp,
-  isUint8Array,
-  normalizedFunctionString
+  isUint8Array
 } from './utils';
 
 /** @public */
@@ -48,24 +45,16 @@ const ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);
  * This will catch any errors in index as a string generation
  */
 
-function serializeString(
-  buffer: Buffer,
-  key: string,
-  value: string,
-  index: number,
-  isArray?: boolean
-) {
+function serializeString(buffer: Uint8Array, key: string, value: string, index: number) {
   // Encode String type
   buffer[index++] = constants.BSON_DATA_STRING;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes + 1;
   buffer[index - 1] = 0;
   // Write the string
-  const size = buffer.write(value, index + 4, undefined, 'utf8');
+  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;
@@ -78,69 +67,48 @@ function serializeString(
   return index;
 }
 
-const SPACE_FOR_FLOAT64 = new Uint8Array(8);
-const DV_FOR_FLOAT64 = new DataView(
-  SPACE_FOR_FLOAT64.buffer,
-  SPACE_FOR_FLOAT64.byteOffset,
-  SPACE_FOR_FLOAT64.byteLength
-);
-function serializeNumber(
-  buffer: Buffer,
-  key: string,
-  value: number,
-  index: number,
-  isArray?: boolean
-) {
-  // We have an integer value
-  // TODO(NODE-2529): Add support for big int
-  if (
-    Number.isInteger(value) &&
-    value >= constants.BSON_INT32_MIN &&
-    value <= constants.BSON_INT32_MAX
-  ) {
-    // If the value fits in 32 bits encode as int32
-    // Set int type 32 bits or less
-    buffer[index++] = constants.BSON_DATA_INT;
-    // Number of written bytes
-    const numberOfWrittenBytes = !isArray
-      ? buffer.write(key, index, undefined, 'utf8')
-      : buffer.write(key, index, undefined, 'ascii');
-    // Encode the name
-    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;
+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);
+
+  const type =
+    !isNegativeZero &&
+    Number.isSafeInteger(value) &&
+    value <= constants.BSON_INT32_MAX &&
+    value >= constants.BSON_INT32_MIN
+      ? constants.BSON_DATA_INT
+      : constants.BSON_DATA_NUMBER;
+
+  if (type === constants.BSON_DATA_INT) {
+    NUMBER_SPACE.setInt32(0, value, true);
   } else {
-    // Encode as double
-    buffer[index++] = constants.BSON_DATA_NUMBER;
-    // Number of written bytes
-    const numberOfWrittenBytes = !isArray
-      ? buffer.write(key, index, undefined, 'utf8')
-      : buffer.write(key, index, undefined, 'ascii');
-    // Encode the name
-    index = index + numberOfWrittenBytes;
-    buffer[index++] = 0;
-    // Write float
-    DV_FOR_FLOAT64.setFloat64(0, value, true);
-    buffer.set(SPACE_FOR_FLOAT64, index);
-    // Adjust index
-    index = index + 8;
+    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;
+
   return index;
 }
 
-function serializeNull(buffer: Buffer, key: string, _: unknown, index: number, isArray?: boolean) {
+function serializeNull(buffer: Uint8Array, key: string, _: unknown, index: number) {
   // Set long type
   buffer[index++] = constants.BSON_DATA_NULL;
 
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
 
   // Encode the name
   index = index + numberOfWrittenBytes;
@@ -148,19 +116,11 @@ function serializeNull(buffer: Buffer, key: string, _: unknown, index: number, i
   return index;
 }
 
-function serializeBoolean(
-  buffer: Buffer,
-  key: string,
-  value: boolean,
-  index: number,
-  isArray?: boolean
-) {
+function serializeBoolean(buffer: Uint8Array, key: string, value: boolean, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_BOOLEAN;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -169,13 +129,11 @@ function serializeBoolean(
   return index;
 }
 
-function serializeDate(buffer: Buffer, key: string, value: Date, index: number, isArray?: boolean) {
+function serializeDate(buffer: Uint8Array, key: string, value: Date, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_DATE;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -197,19 +155,11 @@ function serializeDate(buffer: Buffer, key: string, value: Date, index: number,
   return index;
 }
 
-function serializeRegExp(
-  buffer: Buffer,
-  key: string,
-  value: RegExp,
-  index: number,
-  isArray?: boolean
-) {
+function serializeRegExp(buffer: Uint8Array, key: string, value: RegExp, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_REGEXP;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
 
   // Encode the name
   index = index + numberOfWrittenBytes;
@@ -218,7 +168,7 @@ function serializeRegExp(
     throw Error('value ' + value.source + ' must not contain null bytes');
   }
   // Adjust the index
-  index = index + buffer.write(value.source, index, undefined, 'utf8');
+  index = index + ByteUtils.encodeUTF8Into(buffer, value.source, index);
   // Write zero
   buffer[index++] = 0x00;
   // Write the parameters
@@ -231,19 +181,11 @@ function serializeRegExp(
   return index;
 }
 
-function serializeBSONRegExp(
-  buffer: Buffer,
-  key: string,
-  value: BSONRegExp,
-  index: number,
-  isArray?: boolean
-) {
+function serializeBSONRegExp(buffer: Uint8Array, key: string, value: BSONRegExp, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_REGEXP;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -256,23 +198,18 @@ function serializeBSONRegExp(
   }
 
   // Adjust the index
-  index = index + buffer.write(value.pattern, index, undefined, 'utf8');
+  index = index + ByteUtils.encodeUTF8Into(buffer, value.pattern, index);
   // Write zero
   buffer[index++] = 0x00;
   // Write the options
-  index = index + buffer.write(value.options.split('').sort().join(''), index, undefined, 'utf8');
+  const sortedOptions = value.options.split('').sort().join('');
+  index = index + ByteUtils.encodeUTF8Into(buffer, sortedOptions, index);
   // Add ending zero
   buffer[index++] = 0x00;
   return index;
 }
 
-function serializeMinMax(
-  buffer: Buffer,
-  key: string,
-  value: MinKey | MaxKey,
-  index: number,
-  isArray?: boolean
-) {
+function serializeMinMax(buffer: Uint8Array, key: string, value: MinKey | MaxKey, index: number) {
   // Write the type of either min or max key
   if (value === null) {
     buffer[index++] = constants.BSON_DATA_NULL;
@@ -283,39 +220,25 @@ function serializeMinMax(
   }
 
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   return index;
 }
 
-function serializeObjectId(
-  buffer: Buffer,
-  key: string,
-  value: ObjectId,
-  index: number,
-  isArray?: boolean
-) {
+function serializeObjectId(buffer: Uint8Array, key: string, value: ObjectId, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_OID;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
 
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
 
   // Write the objectId into the shared buffer
-  if (typeof value.id === 'string') {
-    buffer.write(value.id, index, undefined, 'binary');
-  } else if (isUint8Array(value.id)) {
-    // Use the standard JS methods here because buffer.copy() is buggy with the
-    // browser polyfill
+  if (isUint8Array(value.id)) {
     buffer.set(value.id.subarray(0, 12), index);
   } else {
     throw new BSONTypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
@@ -325,19 +248,11 @@ function serializeObjectId(
   return index + 12;
 }
 
-function serializeBuffer(
-  buffer: Buffer,
-  key: string,
-  value: Buffer | Uint8Array,
-  index: number,
-  isArray?: boolean
-) {
+function serializeBuffer(buffer: Uint8Array, key: string, value: Uint8Array, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_BINARY;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -351,36 +266,33 @@ function serializeBuffer(
   // Write the default subtype
   buffer[index++] = constants.BSON_BINARY_SUBTYPE_DEFAULT;
   // Copy the content form the binary field to the buffer
-  buffer.set(ensureBuffer(value), index);
+  buffer.set(value, index);
   // Adjust the index
   index = index + size;
   return index;
 }
 
 function serializeObject(
-  buffer: Buffer,
+  buffer: Uint8Array,
   key: string,
   value: Document,
   index: number,
-  checkKeys = false,
-  depth = 0,
-  serializeFunctions = false,
-  ignoreUndefined = true,
-  isArray = false,
-  path: Document[] = []
+  checkKeys: boolean,
+  depth: number,
+  serializeFunctions: boolean,
+  ignoreUndefined: boolean,
+  path: Set<Document>
 ) {
-  for (let i = 0; i < path.length; i++) {
-    if (path[i] === value) throw new BSONError('cyclic dependency detected');
+  if (path.has(value)) {
+    throw new BSONError('Cannot convert circular structure to BSON');
   }
 
-  // Push value to stack
-  path.push(value);
+  path.add(value);
+
   // Write the type
   buffer[index++] = Array.isArray(value) ? constants.BSON_DATA_ARRAY : constants.BSON_DATA_OBJECT;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -394,41 +306,30 @@ function serializeObject(
     ignoreUndefined,
     path
   );
-  // Pop stack
-  path.pop();
+
+  path.delete(value);
+
   return endIndex;
 }
 
-function serializeDecimal128(
-  buffer: Buffer,
-  key: string,
-  value: Decimal128,
-  index: number,
-  isArray?: boolean
-) {
+function serializeDecimal128(buffer: Uint8Array, key: string, value: Decimal128, index: number) {
   buffer[index++] = constants.BSON_DATA_DECIMAL128;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   // Write the data from the value
-  // Prefer the standard JS methods because their typechecking is not buggy,
-  // unlike the `buffer` polyfill's.
   buffer.set(value.bytes.subarray(0, 16), index);
   return index + 16;
 }
 
-function serializeLong(buffer: Buffer, key: string, value: Long, index: number, isArray?: boolean) {
+function serializeLong(buffer: Uint8Array, key: string, value: Long, index: number) {
   // Write the type
   buffer[index++] =
     value._bsontype === 'Long' ? constants.BSON_DATA_LONG : constants.BSON_DATA_TIMESTAMP;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -448,20 +349,12 @@ function serializeLong(buffer: Buffer, key: string, value: Long, index: number,
   return index;
 }
 
-function serializeInt32(
-  buffer: Buffer,
-  key: string,
-  value: Int32 | number,
-  index: number,
-  isArray?: boolean
-) {
+function serializeInt32(buffer: Uint8Array, key: string, value: Int32 | number, index: number) {
   value = value.valueOf();
   // Set int type 32 bits or less
   buffer[index++] = constants.BSON_DATA_INT;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
@@ -473,56 +366,38 @@ function serializeInt32(
   return index;
 }
 
-function serializeDouble(
-  buffer: Buffer,
-  key: string,
-  value: Double,
-  index: number,
-  isArray?: boolean
-) {
+function serializeDouble(buffer: Uint8Array, key: string, value: Double, index: number) {
   // Encode as double
   buffer[index++] = constants.BSON_DATA_NUMBER;
 
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
 
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
 
   // Write float
-  DV_FOR_FLOAT64.setFloat64(0, value.value, true);
-  buffer.set(SPACE_FOR_FLOAT64, index);
+  NUMBER_SPACE.setFloat64(0, value.value, true);
+  buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
 
   // Adjust index
   index = index + 8;
   return index;
 }
 
-function serializeFunction(
-  buffer: Buffer,
-  key: string,
-  value: Function,
-  index: number,
-  _checkKeys = false,
-  _depth = 0,
-  isArray?: boolean
-) {
+function serializeFunction(buffer: Uint8Array, key: string, value: Function, index: number) {
   buffer[index++] = constants.BSON_DATA_CODE;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   // Function string
-  const functionString = normalizedFunctionString(value);
+  const functionString = value.toString();
 
   // Write the string
-  const size = buffer.write(functionString, index + 4, undefined, 'utf8') + 1;
+  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;
@@ -536,7 +411,7 @@ function serializeFunction(
 }
 
 function serializeCode(
-  buffer: Buffer,
+  buffer: Uint8Array,
   key: string,
   value: Code,
   index: number,
@@ -544,15 +419,13 @@ function serializeCode(
   depth = 0,
   serializeFunctions = false,
   ignoreUndefined = true,
-  isArray = false
+  path: Set<Document>
 ) {
   if (value.scope && typeof value.scope === 'object') {
     // Write the type
     buffer[index++] = constants.BSON_DATA_CODE_W_SCOPE;
     // Number of written bytes
-    const numberOfWrittenBytes = !isArray
-      ? buffer.write(key, index, undefined, 'utf8')
-      : buffer.write(key, index, undefined, 'ascii');
+    const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     // Encode the name
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
@@ -562,11 +435,11 @@ function serializeCode(
 
     // Serialize the function
     // Get the function string
-    const functionString = typeof value.code === 'string' ? value.code : value.code.toString();
+    const functionString = value.code;
     // Index adjustment
     index = index + 4;
     // Write string into buffer
-    const codeSize = buffer.write(functionString, index + 4, undefined, 'utf8') + 1;
+    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;
@@ -577,7 +450,6 @@ function serializeCode(
     // Write the
     index = index + codeSize + 4;
 
-    //
     // Serialize the scope value
     const endIndex = serializeInto(
       buffer,
@@ -586,7 +458,8 @@ function serializeCode(
       index,
       depth + 1,
       serializeFunctions,
-      ignoreUndefined
+      ignoreUndefined,
+      path
     );
     index = endIndex - 1;
 
@@ -603,16 +476,14 @@ function serializeCode(
   } else {
     buffer[index++] = constants.BSON_DATA_CODE;
     // Number of written bytes
-    const numberOfWrittenBytes = !isArray
-      ? buffer.write(key, index, undefined, 'utf8')
-      : buffer.write(key, index, undefined, 'ascii');
+    const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     // Encode the name
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
     // Function string
     const functionString = value.code.toString();
     // Write the string
-    const size = buffer.write(functionString, index + 4, undefined, 'utf8') + 1;
+    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;
@@ -627,24 +498,16 @@ function serializeCode(
   return index;
 }
 
-function serializeBinary(
-  buffer: Buffer,
-  key: string,
-  value: Binary,
-  index: number,
-  isArray?: boolean
-) {
+function serializeBinary(buffer: Uint8Array, key: string, value: Binary, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_BINARY;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   // Extract the buffer
-  const data = value.value(true) as Buffer | Uint8Array;
+  const data = value.buffer;
   // Calculate size
   let size = value.position;
   // Add the deprecated 02 type 4 bytes of size to total
@@ -673,24 +536,16 @@ function serializeBinary(
   return index;
 }
 
-function serializeSymbol(
-  buffer: Buffer,
-  key: string,
-  value: BSONSymbol,
-  index: number,
-  isArray?: boolean
-) {
+function serializeSymbol(buffer: Uint8Array, key: string, value: BSONSymbol, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_SYMBOL;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   // Write the string
-  const size = buffer.write(value.value, index + 4, undefined, 'utf8') + 1;
+  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;
@@ -704,20 +559,18 @@ function serializeSymbol(
 }
 
 function serializeDBRef(
-  buffer: Buffer,
+  buffer: Uint8Array,
   key: string,
   value: DBRef,
   index: number,
   depth: number,
   serializeFunctions: boolean,
-  isArray?: boolean
+  path: Set<Document>
 ) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_OBJECT;
   // Number of written bytes
-  const numberOfWrittenBytes = !isArray
-    ? buffer.write(key, index, undefined, 'utf8')
-    : buffer.write(key, index, undefined, 'ascii');
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
 
   // Encode the name
   index = index + numberOfWrittenBytes;
@@ -734,7 +587,16 @@ function serializeDBRef(
   }
 
   output = Object.assign(output, value.fields);
-  const endIndex = serializeInto(buffer, output, false, index, depth + 1, serializeFunctions);
+  const endIndex = serializeInto(
+    buffer,
+    output,
+    false,
+    index,
+    depth + 1,
+    serializeFunctions,
+    true,
+    path
+  );
 
   // Calculate object size
   const size = endIndex - startIndex;
@@ -748,20 +610,50 @@ function serializeDBRef(
 }
 
 export function serializeInto(
-  buffer: Buffer,
+  buffer: Uint8Array,
   object: Document,
-  checkKeys = false,
-  startingIndex = 0,
-  depth = 0,
-  serializeFunctions = false,
-  ignoreUndefined = true,
-  path: Document[] = []
+  checkKeys: boolean,
+  startingIndex: number,
+  depth: number,
+  serializeFunctions: boolean,
+  ignoreUndefined: boolean,
+  path: Set<Document> | null
 ): number {
-  startingIndex = startingIndex || 0;
-  path = path || [];
+  if (path == null) {
+    // We are at the root input
+    if (object == null) {
+      // ONLY the root should turn into an empty document
+      // BSON Empty document has a size of 5 (LE)
+      buffer[0] = 0x05;
+      buffer[1] = 0x00;
+      buffer[2] = 0x00;
+      buffer[3] = 0x00;
+      // All documents end with null terminator
+      buffer[4] = 0x00;
+      return 5;
+    }
+
+    if (Array.isArray(object)) {
+      throw new BSONError('serialize does not support an array as the root input');
+    }
+    if (typeof object !== 'object') {
+      throw new BSONError('serialize does not support non-object as the root input');
+    } else if ('_bsontype' in object && typeof object._bsontype === 'string') {
+      throw new BSONError(`BSON types cannot be serialized as a document`);
+    } else if (
+      isDate(object) ||
+      isRegExp(object) ||
+      isUint8Array(object) ||
+      isAnyArrayBuffer(object)
+    ) {
+      throw new BSONError(`date, regexp, typedarray, and arraybuffer cannot be BSON documents`);
+    }
+
+    path = new Set();
+  }
 
   // Push the object to the path
-  path.push(object);
+  path.add(object);
 
   // Start place to serialize into
   let index = startingIndex + 4;
@@ -779,26 +671,24 @@ export function serializeInto(
       }
 
       if (typeof value === 'string') {
-        index = serializeString(buffer, key, value, index, true);
+        index = serializeString(buffer, key, value, index);
       } else if (typeof value === 'number') {
-        index = serializeNumber(buffer, key, value, index, true);
+        index = serializeNumber(buffer, key, value, index);
       } else if (typeof value === 'bigint') {
         throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
       } else if (typeof value === 'boolean') {
-        index = serializeBoolean(buffer, key, value, index, true);
+        index = serializeBoolean(buffer, key, value, index);
       } else if (value instanceof Date || isDate(value)) {
-        index = serializeDate(buffer, key, value, index, true);
+        index = serializeDate(buffer, key, value, index);
       } else if (value === undefined) {
-        index = serializeNull(buffer, key, value, index, true);
+        index = serializeNull(buffer, key, value, index);
       } else if (value === null) {
-        index = serializeNull(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {
-        index = serializeObjectId(buffer, key, value, index, true);
+        index = serializeNull(buffer, key, value, index);
       } else if (isUint8Array(value)) {
-        index = serializeBuffer(buffer, key, value, index, true);
+        index = serializeBuffer(buffer, key, value, index);
       } else if (value instanceof RegExp || isRegExp(value)) {
-        index = serializeRegExp(buffer, key, value, index, true);
-      } else if (typeof value === 'object' && value['_bsontype'] == null) {
+        index = serializeRegExp(buffer, key, value, index);
+      } else if (typeof value === 'object' && value._bsontype == null) {
         index = serializeObject(
           buffer,
           key,
@@ -808,22 +698,21 @@ export function serializeInto(
           depth,
           serializeFunctions,
           ignoreUndefined,
-          true,
           path
         );
-      } else if (
-        typeof value === 'object' &&
-        isBSONType(value) &&
-        value._bsontype === 'Decimal128'
-      ) {
-        index = serializeDecimal128(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Timestamp') {
-        index = serializeLong(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'Double') {
-        index = serializeDouble(buffer, key, value, index, true);
+      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
+        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+      } else if (value._bsontype === 'ObjectId') {
+        index = serializeObjectId(buffer, key, value, index);
+      } else if (value._bsontype === 'Decimal128') {
+        index = serializeDecimal128(buffer, key, value, index);
+      } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+        index = serializeLong(buffer, key, value, index);
+      } else if (value._bsontype === 'Double') {
+        index = serializeDouble(buffer, key, value, index);
       } else if (typeof value === 'function' && serializeFunctions) {
-        index = serializeFunction(buffer, key, value, index, checkKeys, depth, true);
-      } else if (value['_bsontype'] === 'Code') {
+        index = serializeFunction(buffer, key, value, index);
+      } else if (value._bsontype === 'Code') {
         index = serializeCode(
           buffer,
           key,
@@ -833,22 +722,22 @@ export function serializeInto(
           depth,
           serializeFunctions,
           ignoreUndefined,
-          true
+          path
         );
-      } else if (value['_bsontype'] === 'Binary') {
-        index = serializeBinary(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'Symbol') {
-        index = serializeSymbol(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'DBRef') {
-        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, true);
-      } else if (value['_bsontype'] === 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'Int32') {
-        index = serializeInt32(buffer, key, value, index, true);
-      } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
-        index = serializeMinMax(buffer, key, value, index, true);
-      } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value['_bsontype'])}`);
+      } else if (value._bsontype === 'Binary') {
+        index = serializeBinary(buffer, key, value, index);
+      } else if (value._bsontype === 'Symbol') {
+        index = serializeSymbol(buffer, key, value, index);
+      } else if (value._bsontype === 'DBRef') {
+        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+      } else if (value._bsontype === 'BSONRegExp') {
+        index = serializeBSONRegExp(buffer, key, value, index);
+      } else if (value._bsontype === 'Int32') {
+        index = serializeInt32(buffer, key, value, index);
+      } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+        index = serializeMinMax(buffer, key, value, index);
+      } else if (typeof value._bsontype !== 'undefined') {
+        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   } else if (object instanceof Map || isMap(object)) {
@@ -898,13 +787,11 @@ export function serializeInto(
         index = serializeDate(buffer, key, value, index);
       } else if (value === null || (value === undefined && ignoreUndefined === false)) {
         index = serializeNull(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {
-        index = serializeObjectId(buffer, key, value, index);
       } else if (isUint8Array(value)) {
         index = serializeBuffer(buffer, key, value, index);
       } else if (value instanceof RegExp || isRegExp(value)) {
         index = serializeRegExp(buffer, key, value, index);
-      } else if (type === 'object' && value['_bsontype'] == null) {
+      } else if (type === 'object' && value._bsontype == null) {
         index = serializeObject(
           buffer,
           key,
@@ -914,16 +801,19 @@ export function serializeInto(
           depth,
           serializeFunctions,
           ignoreUndefined,
-          false,
           path
         );
-      } else if (type === 'object' && value['_bsontype'] === 'Decimal128') {
+      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
+        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+      } else if (value._bsontype === 'ObjectId') {
+        index = serializeObjectId(buffer, key, value, index);
+      } else if (type === 'object' && value._bsontype === 'Decimal128') {
         index = serializeDecimal128(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Timestamp') {
+      } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
         index = serializeLong(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Double') {
+      } else if (value._bsontype === 'Double') {
         index = serializeDouble(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Code') {
+      } else if (value._bsontype === 'Code') {
         index = serializeCode(
           buffer,
           key,
@@ -932,24 +822,25 @@ export function serializeInto(
           checkKeys,
           depth,
           serializeFunctions,
-          ignoreUndefined
+          ignoreUndefined,
+          path
         );
       } else if (typeof value === 'function' && serializeFunctions) {
-        index = serializeFunction(buffer, key, value, index, checkKeys, depth, serializeFunctions);
-      } else if (value['_bsontype'] === 'Binary') {
+        index = serializeFunction(buffer, key, value, index);
+      } else if (value._bsontype === 'Binary') {
         index = serializeBinary(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Symbol') {
+      } else if (value._bsontype === 'Symbol') {
         index = serializeSymbol(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'DBRef') {
-        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions);
-      } else if (value['_bsontype'] === 'BSONRegExp') {
+      } else if (value._bsontype === 'DBRef') {
+        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+      } else if (value._bsontype === 'BSONRegExp') {
         index = serializeBSONRegExp(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Int32') {
+      } else if (value._bsontype === 'Int32') {
         index = serializeInt32(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
+      } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
-      } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value['_bsontype'])}`);
+      } else if (typeof value._bsontype !== 'undefined') {
+        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   } else {
@@ -962,7 +853,7 @@ export function serializeInto(
     }
 
     // Iterate over all the keys
-    for (const key in object) {
+    for (const key of Object.keys(object)) {
       let value = object[key];
       // Is there an override value
       if (typeof value?.toBSON === 'function') {
@@ -1003,13 +894,11 @@ export function serializeInto(
         if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);
       } else if (value === null) {
         index = serializeNull(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'ObjectId' || value['_bsontype'] === 'ObjectID') {
-        index = serializeObjectId(buffer, key, value, index);
       } else if (isUint8Array(value)) {
         index = serializeBuffer(buffer, key, value, index);
       } else if (value instanceof RegExp || isRegExp(value)) {
         index = serializeRegExp(buffer, key, value, index);
-      } else if (type === 'object' && value['_bsontype'] == null) {
+      } else if (type === 'object' && value._bsontype == null) {
         index = serializeObject(
           buffer,
           key,
@@ -1019,16 +908,19 @@ export function serializeInto(
           depth,
           serializeFunctions,
           ignoreUndefined,
-          false,
           path
         );
-      } else if (type === 'object' && value['_bsontype'] === 'Decimal128') {
+      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
+        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+      } else if (value._bsontype === 'ObjectId') {
+        index = serializeObjectId(buffer, key, value, index);
+      } else if (type === 'object' && value._bsontype === 'Decimal128') {
         index = serializeDecimal128(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Long' || value['_bsontype'] === 'Timestamp') {
+      } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
         index = serializeLong(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Double') {
+      } else if (value._bsontype === 'Double') {
         index = serializeDouble(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Code') {
+      } else if (value._bsontype === 'Code') {
         index = serializeCode(
           buffer,
           key,
@@ -1037,30 +929,31 @@ export function serializeInto(
           checkKeys,
           depth,
           serializeFunctions,
-          ignoreUndefined
+          ignoreUndefined,
+          path
         );
       } else if (typeof value === 'function' && serializeFunctions) {
-        index = serializeFunction(buffer, key, value, index, checkKeys, depth, serializeFunctions);
-      } else if (value['_bsontype'] === 'Binary') {
+        index = serializeFunction(buffer, key, value, index);
+      } else if (value._bsontype === 'Binary') {
         index = serializeBinary(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Symbol') {
+      } else if (value._bsontype === 'Symbol') {
         index = serializeSymbol(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'DBRef') {
-        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions);
-      } else if (value['_bsontype'] === 'BSONRegExp') {
+      } else if (value._bsontype === 'DBRef') {
+        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+      } else if (value._bsontype === 'BSONRegExp') {
         index = serializeBSONRegExp(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'Int32') {
+      } else if (value._bsontype === 'Int32') {
         index = serializeInt32(buffer, key, value, index);
-      } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
+      } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
-      } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value['_bsontype'])}`);
+      } else if (typeof value._bsontype !== 'undefined') {
+        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   }
 
   // Remove the path
-  path.pop();
+  path.delete(object);
 
   // Final padding byte for object
   buffer[index++] = 0x00;