bson 6.8.0 → 6.9.0

package/lib/bson.cjs

@@ -1,19 +1,45 @@
 'use strict';
 
+const map = new WeakMap();
+const TYPES = {
+    ArrayBuffer: '[object ArrayBuffer]',
+    SharedArrayBuffer: '[object SharedArrayBuffer]',
+    Uint8Array: '[object Uint8Array]',
+    BigInt64Array: '[object BigInt64Array]',
+    BigUint64Array: '[object BigUint64Array]',
+    RegExp: '[object RegExp]',
+    Map: '[object Map]',
+    Date: '[object Date]'
+};
+function getPrototypeString(value) {
+    let str = map.get(value);
+    if (!str) {
+        str = Object.prototype.toString.call(value);
+        if (value !== null && typeof value === 'object') {
+            map.set(value, str);
+        }
+    }
+    return str;
+}
 function isAnyArrayBuffer(value) {
-    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
+    const type = getPrototypeString(value);
+    return type === TYPES.ArrayBuffer || type === TYPES.SharedArrayBuffer;
 }
 function isUint8Array(value) {
-    return Object.prototype.toString.call(value) === '[object Uint8Array]';
+    const type = getPrototypeString(value);
+    return type === TYPES.Uint8Array;
 }
 function isRegExp(d) {
-    return Object.prototype.toString.call(d) === '[object RegExp]';
+    const type = getPrototypeString(d);
+    return type === TYPES.RegExp;
 }
 function isMap(d) {
-    return Object.prototype.toString.call(d) === '[object Map]';
+    const type = getPrototypeString(d);
+    return type === TYPES.Map;
 }
 function isDate(d) {
-    return Object.prototype.toString.call(d) === '[object Date]';
+    const type = getPrototypeString(d);
+    return type === TYPES.Date;
 }
 function defaultInspect(x, _options) {
     return JSON.stringify(x, (k, v) => {
@@ -37,6 +63,7 @@ function getStylizeFunction(options) {
 }
 
 const BSON_MAJOR_VERSION = 6;
+const BSON_VERSION_SYMBOL = Symbol.for('@@mdb.bson.version');
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
 const BSON_INT64_MAX = Math.pow(2, 63) - 1;
@@ -411,7 +438,7 @@ const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuf
 const ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
 
 class BSONValue {
-    get [Symbol.for('@@mdb.bson.version')]() {
+    get [BSON_VERSION_SYMBOL]() {
         return BSON_MAJOR_VERSION;
     }
     [Symbol.for('nodejs.util.inspect.custom')](depth, options, inspect) {
@@ -1588,7 +1615,7 @@ class Decimal128 extends BSONValue {
         if (typeof bytes === 'string') {
             this.bytes = Decimal128.fromString(bytes).bytes;
         }
-        else if (isUint8Array(bytes)) {
+        else if (bytes instanceof Uint8Array || isUint8Array(bytes)) {
             if (bytes.byteLength !== 16) {
                 throw new BSONError('Decimal128 must take a Buffer of 16 bytes');
             }
@@ -2279,7 +2306,7 @@ const NumberUtils = {
         return 4;
     },
     setBigInt64LE(destination, offset, value) {
-        const mask32bits = BigInt(4294967295);
+        const mask32bits = BigInt(0xffff_ffff);
         let lo = Number(value & mask32bits);
         destination[offset] = lo;
         lo >>= 8;
@@ -2325,7 +2352,6 @@ const NumberUtils = {
         }
 };
 
-const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
 let PROCESS_UNIQUE = null;
 class ObjectId extends BSONValue {
     get _bsontype() {
@@ -2355,7 +2381,7 @@ class ObjectId extends BSONValue {
             this.buffer = ByteUtils.toLocalBufferType(workingId);
         }
         else if (typeof workingId === 'string') {
-            if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+            if (ObjectId.validateHexString(workingId)) {
                 this.buffer = ByteUtils.fromHex(workingId);
             }
             else {
@@ -2378,6 +2404,20 @@ class ObjectId extends BSONValue {
             this.__id = ByteUtils.toHex(value);
         }
     }
+    static validateHexString(string) {
+        if (string?.length !== 24)
+            return false;
+        for (let i = 0; i < 24; i++) {
+            const char = string.charCodeAt(i);
+            if ((char >= 48 && char <= 57) ||
+                (char >= 97 && char <= 102) ||
+                (char >= 65 && char <= 70)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
     toHexString() {
         if (ObjectId.cacheHexString && this.__id) {
             return this.__id;
@@ -2490,6 +2530,8 @@ class ObjectId extends BSONValue {
     static isValid(id) {
         if (id == null)
             return false;
+        if (typeof id === 'string')
+            return ObjectId.validateHexString(id);
         try {
             new ObjectId(id);
             return true;
@@ -2560,7 +2602,7 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
         case 'object':
             if (value != null &&
                 typeof value._bsontype === 'string' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
+                value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
                 throw new BSONVersionError();
             }
             else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
@@ -2764,6 +2806,12 @@ class Timestamp extends LongWithoutOverridesClass {
     get _bsontype() {
         return 'Timestamp';
     }
+    get i() {
+        return this.low >>> 0;
+    }
+    get t() {
+        return this.high >>> 0;
+    }
     constructor(low) {
         if (low == null) {
             super(0, 0, true);
@@ -2789,10 +2837,10 @@ class Timestamp extends LongWithoutOverridesClass {
             if (i < 0 || Number.isNaN(i)) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');
             }
-            if (t > 4294967295) {
+            if (t > 0xffff_ffff) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide t equal or less than uint32 max');
             }
-            if (i > 4294967295) {
+            if (i > 0xffff_ffff) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide i equal or less than uint32 max');
             }
             super(i, t, true);
@@ -2819,7 +2867,7 @@ class Timestamp extends LongWithoutOverridesClass {
         return new Timestamp(Long.fromString(str, true, optRadix));
     }
     toExtendedJSON() {
-        return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };
+        return { $timestamp: { t: this.t, i: this.i } };
     }
     static fromExtendedJSON(doc) {
         const i = Long.isLong(doc.$timestamp.i)
@@ -2832,8 +2880,8 @@ class Timestamp extends LongWithoutOverridesClass {
     }
     inspect(depth, options, inspect) {
         inspect ??= defaultInspect;
-        const t = inspect(this.high >>> 0, options);
-        const i = inspect(this.low >>> 0, options);
+        const t = inspect(this.t, options);
+        const i = inspect(this.i, options);
         return `new Timestamp({ t: ${t}, i: ${i} })`;
     }
 }
@@ -3602,79 +3650,83 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             if (typeof value?.toBSON === 'function') {
                 value = value.toBSON();
             }
-            if (typeof value === 'string') {
-                index = serializeString(buffer, key, value, index);
-            }
-            else if (typeof value === 'number') {
-                index = serializeNumber(buffer, key, value, index);
-            }
-            else if (typeof value === 'bigint') {
-                index = serializeBigInt(buffer, key, value, index);
-            }
-            else if (typeof value === 'boolean') {
-                index = serializeBoolean(buffer, key, value, index);
-            }
-            else if (value instanceof Date || isDate(value)) {
-                index = serializeDate(buffer, key, value, index);
-            }
-            else if (value === undefined) {
+            const type = typeof value;
+            if (value === undefined) {
                 index = serializeNull(buffer, key, value, index);
             }
             else if (value === null) {
                 index = serializeNull(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 (typeof value === 'object' && value._bsontype == null) {
-                index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+            else if (type === 'string') {
+                index = serializeString(buffer, key, value, index);
             }
-            else if (typeof value === 'object' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
-                throw new BSONVersionError();
+            else if (type === 'number') {
+                index = serializeNumber(buffer, key, value, index);
             }
-            else if (value._bsontype === 'ObjectId') {
-                index = serializeObjectId(buffer, key, value, index);
+            else if (type === 'bigint') {
+                index = serializeBigInt(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Decimal128') {
-                index = serializeDecimal128(buffer, key, value, index);
+            else if (type === 'boolean') {
+                index = serializeBoolean(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-                index = serializeLong(buffer, key, value, index);
+            else if (type === 'object' && value._bsontype == null) {
+                if (value instanceof Date || isDate(value)) {
+                    index = serializeDate(buffer, key, value, index);
+                }
+                else if (value instanceof Uint8Array || isUint8Array(value)) {
+                    index = serializeBuffer(buffer, key, value, index);
+                }
+                else if (value instanceof RegExp || isRegExp(value)) {
+                    index = serializeRegExp(buffer, key, value, index);
+                }
+                else {
+                    index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
             }
-            else if (value._bsontype === 'Double') {
-                index = serializeDouble(buffer, key, value, index);
+            else if (type === 'object') {
+                if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+                    throw new BSONVersionError();
+                }
+                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 (value._bsontype === 'Code') {
+                    index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
+                else if (value._bsontype === 'Binary') {
+                    index = serializeBinary(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'BSONSymbol') {
+                    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 BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                }
             }
-            else if (typeof value === 'function' && serializeFunctions) {
+            else if (type === 'function' && serializeFunctions) {
                 index = serializeFunction(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Code') {
-                index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
-            }
-            else if (value._bsontype === 'Binary') {
-                index = serializeBinary(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'BSONSymbol') {
-                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 BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-            }
         }
     }
     else if (object instanceof Map || isMap(object)) {
@@ -3704,7 +3756,14 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                     }
                 }
             }
-            if (type === 'string') {
+            if (value === undefined) {
+                if (ignoreUndefined === false)
+                    index = serializeNull(buffer, key, value, index);
+            }
+            else if (value === null) {
+                index = serializeNull(buffer, key, value, index);
+            }
+            else if (type === 'string') {
                 index = serializeString(buffer, key, value, index);
             }
             else if (type === 'number') {
@@ -3716,64 +3775,64 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             else if (type === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
             }
-            else if (value instanceof Date || isDate(value)) {
-                index = serializeDate(buffer, key, value, index);
-            }
-            else if (value === null || (value === undefined && ignoreUndefined === false)) {
-                index = serializeNull(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) {
-                index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
-            }
-            else if (typeof value === 'object' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
-                throw new BSONVersionError();
-            }
-            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') {
-                index = serializeLong(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Double') {
-                index = serializeDouble(buffer, key, value, index);
+                if (value instanceof Date || isDate(value)) {
+                    index = serializeDate(buffer, key, value, index);
+                }
+                else if (value instanceof Uint8Array || isUint8Array(value)) {
+                    index = serializeBuffer(buffer, key, value, index);
+                }
+                else if (value instanceof RegExp || isRegExp(value)) {
+                    index = serializeRegExp(buffer, key, value, index);
+                }
+                else {
+                    index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
             }
-            else if (value._bsontype === 'Code') {
-                index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+            else if (type === 'object') {
+                if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+                    throw new BSONVersionError();
+                }
+                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 (value._bsontype === 'Code') {
+                    index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
+                else if (value._bsontype === 'Binary') {
+                    index = serializeBinary(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'BSONSymbol') {
+                    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 BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                }
             }
-            else if (typeof value === 'function' && serializeFunctions) {
+            else if (type === 'function' && serializeFunctions) {
                 index = serializeFunction(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Binary') {
-                index = serializeBinary(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'BSONSymbol') {
-                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 BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-            }
         }
     }
     else {
@@ -3802,7 +3861,14 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                     }
                 }
             }
-            if (type === 'string') {
+            if (value === undefined) {
+                if (ignoreUndefined === false)
+                    index = serializeNull(buffer, key, value, index);
+            }
+            else if (value === null) {
+                index = serializeNull(buffer, key, value, index);
+            }
+            else if (type === 'string') {
                 index = serializeString(buffer, key, value, index);
             }
             else if (type === 'number') {
@@ -3814,68 +3880,64 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             else if (type === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
             }
-            else if (value instanceof Date || isDate(value)) {
-                index = serializeDate(buffer, key, value, index);
-            }
-            else if (value === undefined) {
-                if (ignoreUndefined === false)
-                    index = serializeNull(buffer, key, value, index);
-            }
-            else if (value === null) {
-                index = serializeNull(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) {
-                index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
-            }
-            else if (typeof value === 'object' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
-                throw new BSONVersionError();
-            }
-            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') {
-                index = serializeLong(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Double') {
-                index = serializeDouble(buffer, key, value, index);
+                if (value instanceof Date || isDate(value)) {
+                    index = serializeDate(buffer, key, value, index);
+                }
+                else if (value instanceof Uint8Array || isUint8Array(value)) {
+                    index = serializeBuffer(buffer, key, value, index);
+                }
+                else if (value instanceof RegExp || isRegExp(value)) {
+                    index = serializeRegExp(buffer, key, value, index);
+                }
+                else {
+                    index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
             }
-            else if (value._bsontype === 'Code') {
-                index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+            else if (type === 'object') {
+                if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+                    throw new BSONVersionError();
+                }
+                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 (value._bsontype === 'Code') {
+                    index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
+                else if (value._bsontype === 'Binary') {
+                    index = serializeBinary(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'BSONSymbol') {
+                    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 BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                }
             }
-            else if (typeof value === 'function' && serializeFunctions) {
+            else if (type === 'function' && serializeFunctions) {
                 index = serializeFunction(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Binary') {
-                index = serializeBinary(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'BSONSymbol') {
-                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 BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-            }
         }
     }
     path.delete(object);
@@ -4127,7 +4189,7 @@ function serializeDocument(doc, options) {
     else if (doc != null &&
         typeof doc === 'object' &&
         typeof doc._bsontype === 'string' &&
-        doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
+        doc[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
         throw new BSONVersionError();
     }
     else if (isBSONType(doc)) {