bson 6.8.0 → 6.10.0

package/lib/bson.rn.cjs

@@ -1,25 +1,53 @@
 '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 isBigInt64Array(value) {
-    return Object.prototype.toString.call(value) === '[object BigInt64Array]';
+    const type = getPrototypeString(value);
+    return type === TYPES.BigInt64Array;
 }
 function isBigUInt64Array(value) {
-    return Object.prototype.toString.call(value) === '[object BigUint64Array]';
+    const type = getPrototypeString(value);
+    return type === TYPES.BigUint64Array;
 }
 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) => {
@@ -43,6 +71,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;
@@ -244,7 +273,7 @@ const nodeJsByteUtils = {
             stringTag === '[object SharedArrayBuffer]') {
             return Buffer.from(potentialBuffer);
         }
-        throw new BSONError(`Cannot create Buffer from ${String(potentialBuffer)}`);
+        throw new BSONError(`Cannot create Buffer from the passed potentialBuffer.`);
     },
     allocate(size) {
         return Buffer.alloc(size);
@@ -302,7 +331,10 @@ const nodeJsByteUtils = {
         }
         return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');
     },
-    randomBytes: nodejsRandomBytes
+    randomBytes: nodejsRandomBytes,
+    swap32(buffer) {
+        return nodeJsByteUtils.toLocalBufferType(buffer).swap32();
+    }
 };
 
 const { TextEncoder } = require('../vendor/text-encoding');
@@ -349,7 +381,7 @@ const webByteUtils = {
             stringTag === '[object SharedArrayBuffer]') {
             return new Uint8Array(potentialUint8array);
         }
-        throw new BSONError(`Cannot make a Uint8Array from ${String(potentialUint8array)}`);
+        throw new BSONError(`Cannot make a Uint8Array from passed potentialBuffer.`);
     },
     allocate(size) {
         if (typeof size !== 'number') {
@@ -421,14 +453,30 @@ const webByteUtils = {
         uint8array.set(bytes, byteOffset);
         return bytes.byteLength;
     },
-    randomBytes: webRandomBytes
+    randomBytes: webRandomBytes,
+    swap32(buffer) {
+        if (buffer.length % 4 !== 0) {
+            throw new RangeError('Buffer size must be a multiple of 32-bits');
+        }
+        for (let i = 0; i < buffer.length; i += 4) {
+            const byte0 = buffer[i];
+            const byte1 = buffer[i + 1];
+            const byte2 = buffer[i + 2];
+            const byte3 = buffer[i + 3];
+            buffer[i] = byte3;
+            buffer[i + 1] = byte2;
+            buffer[i + 2] = byte1;
+            buffer[i + 3] = byte0;
+        }
+        return buffer;
+    }
 };
 
 const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuffer !== true;
 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) {
@@ -436,6 +484,134 @@ class BSONValue {
     }
 }
 
+const FLOAT = new Float64Array(1);
+const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+FLOAT[0] = -1;
+const isBigEndian = FLOAT_BYTES[7] === 0;
+const NumberUtils = {
+    isBigEndian,
+    getNonnegativeInt32LE(source, offset) {
+        if (source[offset + 3] > 127) {
+            throw new RangeError(`Size cannot be negative at offset: ${offset}`);
+        }
+        return (source[offset] |
+            (source[offset + 1] << 8) |
+            (source[offset + 2] << 16) |
+            (source[offset + 3] << 24));
+    },
+    getInt32LE(source, offset) {
+        return (source[offset] |
+            (source[offset + 1] << 8) |
+            (source[offset + 2] << 16) |
+            (source[offset + 3] << 24));
+    },
+    getUint32LE(source, offset) {
+        return (source[offset] +
+            source[offset + 1] * 256 +
+            source[offset + 2] * 65536 +
+            source[offset + 3] * 16777216);
+    },
+    getUint32BE(source, offset) {
+        return (source[offset + 3] +
+            source[offset + 2] * 256 +
+            source[offset + 1] * 65536 +
+            source[offset] * 16777216);
+    },
+    getBigInt64LE(source, offset) {
+        const lo = NumberUtils.getUint32LE(source, offset);
+        const hi = NumberUtils.getUint32LE(source, offset + 4);
+        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    },
+    getFloat64LE: isBigEndian
+        ? (source, offset) => {
+            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, offset) => {
+            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];
+        },
+    setInt32BE(destination, offset, value) {
+        destination[offset + 3] = value;
+        value >>>= 8;
+        destination[offset + 2] = value;
+        value >>>= 8;
+        destination[offset + 1] = value;
+        value >>>= 8;
+        destination[offset] = value;
+        return 4;
+    },
+    setInt32LE(destination, offset, value) {
+        destination[offset] = value;
+        value >>>= 8;
+        destination[offset + 1] = value;
+        value >>>= 8;
+        destination[offset + 2] = value;
+        value >>>= 8;
+        destination[offset + 3] = value;
+        return 4;
+    },
+    setBigInt64LE(destination, offset, value) {
+        const mask32bits = BigInt(0xffff_ffff);
+        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;
+        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;
+    },
+    setFloat64LE: isBigEndian
+        ? (destination, offset, value) => {
+            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, offset, value) => {
+            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;
+        }
+};
+
 class Binary extends BSONValue {
     get _bsontype() {
         return 'Binary';
@@ -508,7 +684,8 @@ class Binary extends BSONValue {
     }
     read(position, length) {
         length = length && length > 0 ? length : this.position;
-        return this.buffer.slice(position, position + length);
+        const end = position + length;
+        return this.buffer.subarray(position, end > this.position ? this.position : end);
     }
     value() {
         return this.buffer.length === this.position
@@ -532,6 +709,9 @@ class Binary extends BSONValue {
     }
     toExtendedJSON(options) {
         options = options || {};
+        if (this.sub_type === Binary.SUBTYPE_VECTOR) {
+            validateBinaryVector(this);
+        }
         const base64String = ByteUtils.toBase64(this.buffer);
         const subType = Number(this.sub_type).toString(16);
         if (options.legacy) {
@@ -549,7 +729,7 @@ class Binary extends BSONValue {
     }
     toUUID() {
         if (this.sub_type === Binary.SUBTYPE_UUID) {
-            return new UUID(this.buffer.slice(0, this.position));
+            return new UUID(this.buffer.subarray(0, this.position));
         }
         throw new BSONError(`Binary sub_type "${this.sub_type}" is not supported for converting to UUID. Only "${Binary.SUBTYPE_UUID}" is currently supported.`);
     }
@@ -591,6 +771,99 @@ class Binary extends BSONValue {
         const subTypeArg = inspect(this.sub_type, options);
         return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`;
     }
+    toInt8Array() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.Int8) {
+            throw new BSONError('Binary datatype field is not Int8');
+        }
+        return new Int8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
+    }
+    toFloat32Array() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.Float32) {
+            throw new BSONError('Binary datatype field is not Float32');
+        }
+        const floatBytes = new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
+        if (NumberUtils.isBigEndian)
+            ByteUtils.swap32(floatBytes);
+        return new Float32Array(floatBytes.buffer);
+    }
+    toPackedBits() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
+            throw new BSONError('Binary datatype field is not packed bit');
+        }
+        return new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
+    }
+    toBits() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
+            throw new BSONError('Binary datatype field is not packed bit');
+        }
+        const byteCount = this.length() - 2;
+        const bitCount = byteCount * 8 - this.buffer[1];
+        const bits = new Int8Array(bitCount);
+        for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) {
+            const byteOffset = (bitOffset / 8) | 0;
+            const byte = this.buffer[byteOffset + 2];
+            const shift = 7 - (bitOffset % 8);
+            const bit = (byte >> shift) & 1;
+            bits[bitOffset] = bit;
+        }
+        return bits;
+    }
+    static fromInt8Array(array) {
+        const buffer = ByteUtils.allocate(array.byteLength + 2);
+        buffer[0] = Binary.VECTOR_TYPE.Int8;
+        buffer[1] = 0;
+        const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        buffer.set(intBytes, 2);
+        return new this(buffer, this.SUBTYPE_VECTOR);
+    }
+    static fromFloat32Array(array) {
+        const binaryBytes = ByteUtils.allocate(array.byteLength + 2);
+        binaryBytes[0] = Binary.VECTOR_TYPE.Float32;
+        binaryBytes[1] = 0;
+        const floatBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        binaryBytes.set(floatBytes, 2);
+        if (NumberUtils.isBigEndian)
+            ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2));
+        return new this(binaryBytes, this.SUBTYPE_VECTOR);
+    }
+    static fromPackedBits(array, padding = 0) {
+        const buffer = ByteUtils.allocate(array.byteLength + 2);
+        buffer[0] = Binary.VECTOR_TYPE.PackedBit;
+        buffer[1] = padding;
+        buffer.set(array, 2);
+        return new this(buffer, this.SUBTYPE_VECTOR);
+    }
+    static fromBits(bits) {
+        const byteLength = (bits.length + 7) >>> 3;
+        const bytes = new Uint8Array(byteLength + 2);
+        bytes[0] = Binary.VECTOR_TYPE.PackedBit;
+        const remainder = bits.length % 8;
+        bytes[1] = remainder === 0 ? 0 : 8 - remainder;
+        for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) {
+            const byteOffset = bitOffset >>> 3;
+            const bit = bits[bitOffset];
+            if (bit !== 0 && bit !== 1) {
+                throw new BSONError(`Invalid bit value at ${bitOffset}: must be 0 or 1, found ${bits[bitOffset]}`);
+            }
+            if (bit === 0)
+                continue;
+            const shift = 7 - (bitOffset % 8);
+            bytes[byteOffset + 2] |= bit << shift;
+        }
+        return new this(bytes, Binary.SUBTYPE_VECTOR);
+    }
 }
 Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
 Binary.BUFFER_SIZE = 256;
@@ -603,7 +876,30 @@ Binary.SUBTYPE_MD5 = 5;
 Binary.SUBTYPE_ENCRYPTED = 6;
 Binary.SUBTYPE_COLUMN = 7;
 Binary.SUBTYPE_SENSITIVE = 8;
+Binary.SUBTYPE_VECTOR = 9;
 Binary.SUBTYPE_USER_DEFINED = 128;
+Binary.VECTOR_TYPE = Object.freeze({
+    Int8: 0x03,
+    Float32: 0x27,
+    PackedBit: 0x10
+});
+function validateBinaryVector(vector) {
+    if (vector.sub_type !== Binary.SUBTYPE_VECTOR)
+        return;
+    const size = vector.position;
+    const datatype = vector.buffer[0];
+    const padding = vector.buffer[1];
+    if ((datatype === Binary.VECTOR_TYPE.Float32 || datatype === Binary.VECTOR_TYPE.Int8) &&
+        padding !== 0) {
+        throw new BSONError('Invalid Vector: padding must be zero for int8 and float32 vectors');
+    }
+    if (datatype === Binary.VECTOR_TYPE.PackedBit && padding !== 0 && size === 2) {
+        throw new BSONError('Invalid Vector: padding must be zero for packed bit vectors that are empty');
+    }
+    if (datatype === Binary.VECTOR_TYPE.PackedBit && padding > 7) {
+        throw new BSONError(`Invalid Vector: padding must be a value between 0 and 7. found: ${padding}`);
+    }
+}
 const UUID_BYTE_LENGTH = 16;
 const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
 const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
@@ -1605,7 +1901,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');
             }
@@ -2215,134 +2511,6 @@ class MinKey extends BSONValue {
     }
 }
 
-const FLOAT = new Float64Array(1);
-const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
-FLOAT[0] = -1;
-const isBigEndian = FLOAT_BYTES[7] === 0;
-const NumberUtils = {
-    getNonnegativeInt32LE(source, offset) {
-        if (source[offset + 3] > 127) {
-            throw new RangeError(`Size cannot be negative at offset: ${offset}`);
-        }
-        return (source[offset] |
-            (source[offset + 1] << 8) |
-            (source[offset + 2] << 16) |
-            (source[offset + 3] << 24));
-    },
-    getInt32LE(source, offset) {
-        return (source[offset] |
-            (source[offset + 1] << 8) |
-            (source[offset + 2] << 16) |
-            (source[offset + 3] << 24));
-    },
-    getUint32LE(source, offset) {
-        return (source[offset] +
-            source[offset + 1] * 256 +
-            source[offset + 2] * 65536 +
-            source[offset + 3] * 16777216);
-    },
-    getUint32BE(source, offset) {
-        return (source[offset + 3] +
-            source[offset + 2] * 256 +
-            source[offset + 1] * 65536 +
-            source[offset] * 16777216);
-    },
-    getBigInt64LE(source, offset) {
-        const lo = NumberUtils.getUint32LE(source, offset);
-        const hi = NumberUtils.getUint32LE(source, offset + 4);
-        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
-    },
-    getFloat64LE: isBigEndian
-        ? (source, offset) => {
-            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, offset) => {
-            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];
-        },
-    setInt32BE(destination, offset, value) {
-        destination[offset + 3] = value;
-        value >>>= 8;
-        destination[offset + 2] = value;
-        value >>>= 8;
-        destination[offset + 1] = value;
-        value >>>= 8;
-        destination[offset] = value;
-        return 4;
-    },
-    setInt32LE(destination, offset, value) {
-        destination[offset] = value;
-        value >>>= 8;
-        destination[offset + 1] = value;
-        value >>>= 8;
-        destination[offset + 2] = value;
-        value >>>= 8;
-        destination[offset + 3] = value;
-        return 4;
-    },
-    setBigInt64LE(destination, offset, value) {
-        const mask32bits = BigInt(4294967295);
-        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;
-        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;
-    },
-    setFloat64LE: isBigEndian
-        ? (destination, offset, value) => {
-            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, offset, value) => {
-            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;
-        }
-};
-
-const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
 let PROCESS_UNIQUE = null;
 class ObjectId extends BSONValue {
     get _bsontype() {
@@ -2372,7 +2540,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 {
@@ -2395,6 +2563,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;
@@ -2507,6 +2689,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;
@@ -2577,7 +2761,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') {
@@ -2781,6 +2965,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);
@@ -2806,10 +2996,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);
@@ -2836,7 +3026,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)
@@ -2849,8 +3039,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} })`;
     }
 }
@@ -3007,7 +3197,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (objectSize <= 0 || objectSize > buffer.length - index)
                 throw new BSONError('bad embedded document length in bson');
             if (raw) {
-                value = buffer.slice(index, index + objectSize);
+                value = buffer.subarray(index, index + objectSize);
             }
             else {
                 let objectOptions = options;
@@ -3079,49 +3269,23 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 throw new BSONError('Negative binary type element size found');
             if (binarySize > buffer.byteLength)
                 throw new BSONError('Binary type size larger than document size');
-            if (buffer['slice'] != null) {
-                if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-                    binarySize = NumberUtils.getInt32LE(buffer, index);
-                    index += 4;
-                    if (binarySize < 0)
-                        throw new BSONError('Negative binary type element size found for subtype 0x02');
-                    if (binarySize > totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
-                    if (binarySize < totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
-                }
-                if (promoteBuffers && promoteValues) {
-                    value = ByteUtils.toLocalBufferType(buffer.slice(index, index + binarySize));
-                }
-                else {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
-                        value = value.toUUID();
-                    }
-                }
+            if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
+                binarySize = NumberUtils.getInt32LE(buffer, index);
+                index += 4;
+                if (binarySize < 0)
+                    throw new BSONError('Negative binary type element size found for subtype 0x02');
+                if (binarySize > totalBinarySize - 4)
+                    throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
+                if (binarySize < totalBinarySize - 4)
+                    throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
+            }
+            if (promoteBuffers && promoteValues) {
+                value = ByteUtils.toLocalBufferType(buffer.subarray(index, index + binarySize));
             }
             else {
-                if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-                    binarySize = NumberUtils.getInt32LE(buffer, index);
-                    index += 4;
-                    if (binarySize < 0)
-                        throw new BSONError('Negative binary type element size found for subtype 0x02');
-                    if (binarySize > totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
-                    if (binarySize < totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
-                }
-                if (promoteBuffers && promoteValues) {
-                    value = ByteUtils.allocateUnsafe(binarySize);
-                    for (i = 0; i < binarySize; i++) {
-                        value[i] = buffer[index + i];
-                    }
-                }
-                else {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
-                        value = value.toUUID();
-                    }
+                value = new Binary(buffer.subarray(index, index + binarySize), subType);
+                if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
+                    value = value.toUUID();
                 }
             }
             index = index + binarySize;
@@ -3543,6 +3707,9 @@ function serializeBinary(buffer, key, value, index) {
         size = size - 4;
         index += NumberUtils.setInt32LE(buffer, index, size);
     }
+    if (value.sub_type === Binary.SUBTYPE_VECTOR) {
+        validateBinaryVector(value);
+    }
     if (size <= 16) {
         for (let i = 0; i < size; i++)
             buffer[index + i] = data[i];
@@ -3619,79 +3786,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)) {
@@ -3721,7 +3892,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') {
@@ -3733,64 +3911,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 {
@@ -3819,7 +3997,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') {
@@ -3831,68 +4016,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);
@@ -4144,7 +4325,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)) {