bson 5.0.0-alpha.1 → 5.0.0-alpha.2

package/lib/bson.cjs

@@ -1,19 +1,23 @@
 'use strict';
 
 class BSONError extends Error {
-    constructor(message) {
-        super(message);
+    get bsonError() {
+        return true;
     }
     get name() {
         return 'BSONError';
     }
-}
-class BSONTypeError extends TypeError {
     constructor(message) {
         super(message);
     }
-    get name() {
-        return 'BSONTypeError';
+    static isBSONError(value) {
+        return (value != null &&
+            typeof value === 'object' &&
+            'bsonError' in value &&
+            value.bsonError === true &&
+            'name' in value &&
+            'message' in value &&
+            'stack' in value);
     }
 }
 
@@ -212,7 +216,7 @@ const VALIDATION_REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f
 const uuidValidateString = (str) => typeof str === 'string' && VALIDATION_REGEX.test(str);
 const uuidHexStringToBuffer = (hexString) => {
     if (!uuidValidateString(hexString)) {
-        throw new BSONTypeError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
+        throw new BSONError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
     }
     const sanitizedHexString = hexString.replace(/-/g, '');
     return ByteUtils.fromHex(sanitizedHexString);
@@ -236,12 +240,6 @@ function isAnyArrayBuffer(value) {
 function isUint8Array(value) {
     return Object.prototype.toString.call(value) === '[object Uint8Array]';
 }
-function isBigInt64Array(value) {
-    return Object.prototype.toString.call(value) === '[object BigInt64Array]';
-}
-function isBigUInt64Array(value) {
-    return Object.prototype.toString.call(value) === '[object BigUint64Array]';
-}
 function isRegExp(d) {
     return Object.prototype.toString.call(d) === '[object RegExp]';
 }
@@ -319,7 +317,7 @@ class Binary {
             !ArrayBuffer.isView(buffer) &&
             !(buffer instanceof ArrayBuffer) &&
             !Array.isArray(buffer)) {
-            throw new BSONTypeError('Binary can only be constructed from string, Buffer, TypedArray, or Array<number>');
+            throw new BSONError('Binary can only be constructed from string, Buffer, TypedArray, or Array<number>');
         }
         this.sub_type = subType ?? Binary.BSON_BINARY_SUBTYPE_DEFAULT;
         if (buffer == null) {
@@ -341,10 +339,10 @@ class Binary {
     }
     put(byteValue) {
         if (typeof byteValue === 'string' && byteValue.length !== 1) {
-            throw new BSONTypeError('only accepts single character String');
+            throw new BSONError('only accepts single character String');
         }
         else if (typeof byteValue !== 'number' && byteValue.length !== 1)
-            throw new BSONTypeError('only accepts single character Uint8Array or Array');
+            throw new BSONError('only accepts single character Uint8Array or Array');
         let decodedByte;
         if (typeof byteValue === 'string') {
             decodedByte = byteValue.charCodeAt(0);
@@ -356,7 +354,7 @@ class Binary {
             decodedByte = byteValue[0];
         }
         if (decodedByte < 0 || decodedByte > 255) {
-            throw new BSONTypeError('only accepts number in a valid unsigned byte range 0-255');
+            throw new BSONError('only accepts number in a valid unsigned byte range 0-255');
         }
         if (this.buffer.byteLength > this.position) {
             this.buffer[this.position++] = decodedByte;
@@ -460,7 +458,7 @@ class Binary {
             data = uuidHexStringToBuffer(doc.$uuid);
         }
         if (!data) {
-            throw new BSONTypeError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
+            throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
         }
         return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);
     }
@@ -504,7 +502,7 @@ class UUID extends Binary {
             bytes = uuidHexStringToBuffer(input);
         }
         else {
-            throw new BSONTypeError('Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).');
+            throw new BSONError('Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).');
         }
         super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);
         this.__id = hexStr;
@@ -788,7 +786,7 @@ class Long {
     }
     static fromString(str, unsigned, radix) {
         if (str.length === 0)
-            throw Error('empty string');
+            throw new BSONError('empty string');
         if (str === 'NaN' || str === 'Infinity' || str === '+Infinity' || str === '-Infinity')
             return Long.ZERO;
         if (typeof unsigned === 'number') {
@@ -799,10 +797,10 @@ class Long {
         }
         radix = radix || 10;
         if (radix < 2 || 36 < radix)
-            throw RangeError('radix');
+            throw new BSONError('radix');
         let p;
         if ((p = str.indexOf('-')) > 0)
-            throw Error('interior hyphen');
+            throw new BSONError('interior hyphen');
         else if (p === 0) {
             return Long.fromString(str.substring(1), unsigned, radix).neg();
         }
@@ -898,7 +896,7 @@ class Long {
         if (!Long.isLong(divisor))
             divisor = Long.fromValue(divisor);
         if (divisor.isZero())
-            throw Error('division by zero');
+            throw new BSONError('division by zero');
         if (wasm) {
             if (!this.unsigned &&
                 this.high === -0x80000000 &&
@@ -1253,7 +1251,7 @@ class Long {
     toString(radix) {
         radix = radix || 10;
         if (radix < 2 || 36 < radix)
-            throw RangeError('radix');
+            throw new BSONError('radix');
         if (this.isZero())
             return '0';
         if (this.isNegative()) {
@@ -1397,7 +1395,7 @@ function lessThan(left, right) {
     return false;
 }
 function invalidErr(string, message) {
-    throw new BSONTypeError(`"${string}" is not a valid Decimal128 string - ${message}`);
+    throw new BSONError(`"${string}" is not a valid Decimal128 string - ${message}`);
 }
 class Decimal128 {
     get _bsontype() {
@@ -1412,12 +1410,12 @@ class Decimal128 {
         }
         else if (isUint8Array(bytes)) {
             if (bytes.byteLength !== 16) {
-                throw new BSONTypeError('Decimal128 must take a Buffer of 16 bytes');
+                throw new BSONError('Decimal128 must take a Buffer of 16 bytes');
             }
             this.bytes = bytes;
         }
         else {
-            throw new BSONTypeError('Decimal128 must take a Buffer or string');
+            throw new BSONError('Decimal128 must take a Buffer or string');
         }
     }
     static fromString(representation) {
@@ -1441,13 +1439,13 @@ class Decimal128 {
         let biasedExponent = 0;
         let index = 0;
         if (representation.length >= 7000) {
-            throw new BSONTypeError('' + representation + ' not a valid Decimal128 string');
+            throw new BSONError('' + representation + ' not a valid Decimal128 string');
         }
         const stringMatch = representation.match(PARSE_STRING_REGEXP);
         const infMatch = representation.match(PARSE_INF_REGEXP);
         const nanMatch = representation.match(PARSE_NAN_REGEXP);
         if ((!stringMatch && !infMatch && !nanMatch) || representation.length === 0) {
-            throw new BSONTypeError('' + representation + ' not a valid Decimal128 string');
+            throw new BSONError('' + representation + ' not a valid Decimal128 string');
         }
         if (stringMatch) {
             const unsignedNumber = stringMatch[2];
@@ -1499,7 +1497,7 @@ class Decimal128 {
             index = index + 1;
         }
         if (sawRadix && !nDigitsRead)
-            throw new BSONTypeError('' + representation + ' not a valid Decimal128 string');
+            throw new BSONError('' + representation + ' not a valid Decimal128 string');
         if (representation[index] === 'e' || representation[index] === 'E') {
             const match = representation.substr(++index).match(EXPONENT_REGEX);
             if (!match || !match[2])
@@ -1855,19 +1853,11 @@ class Double {
             return this.value;
         }
         if (Object.is(Math.sign(this.value), -0)) {
-            return { $numberDouble: `-${this.value.toFixed(1)}` };
-        }
-        let $numberDouble;
-        if (Number.isInteger(this.value)) {
-            $numberDouble = this.value.toFixed(1);
-            if ($numberDouble.length >= 13) {
-                $numberDouble = this.value.toExponential(13).toUpperCase();
-            }
+            return { $numberDouble: '-0.0' };
         }
-        else {
-            $numberDouble = this.value.toString();
-        }
-        return { $numberDouble };
+        return {
+            $numberDouble: Number.isInteger(this.value) ? this.value.toFixed(1) : this.value.toString()
+        };
     }
     static fromExtendedJSON(doc, options) {
         const doubleValue = parseFloat(doc.$numberDouble);
@@ -1976,7 +1966,7 @@ class ObjectId {
         let workingId;
         if (typeof inputId === 'object' && inputId && 'id' in inputId) {
             if (typeof inputId.id !== 'string' && !ArrayBuffer.isView(inputId.id)) {
-                throw new BSONTypeError('Argument passed in must have an id that is of type string or Buffer');
+                throw new BSONError('Argument passed in must have an id that is of type string or Buffer');
             }
             if ('toHexString' in inputId && typeof inputId.toHexString === 'function') {
                 workingId = ByteUtils.fromHex(inputId.toHexString());
@@ -2001,18 +1991,18 @@ class ObjectId {
                     this[kId] = bytes;
                 }
                 else {
-                    throw new BSONTypeError('Argument passed in must be a string of 12 bytes');
+                    throw new BSONError('Argument passed in must be a string of 12 bytes');
                 }
             }
             else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
                 this[kId] = ByteUtils.fromHex(workingId);
             }
             else {
-                throw new BSONTypeError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer');
+                throw new BSONError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer');
             }
         }
         else {
-            throw new BSONTypeError('Argument passed in does not match the accepted types');
+            throw new BSONError('Argument passed in does not match the accepted types');
         }
         if (ObjectId.cacheHexString) {
             this.__id = ByteUtils.toHex(this.id);
@@ -2114,7 +2104,7 @@ class ObjectId {
     }
     static createFromHexString(hexString) {
         if (typeof hexString === 'undefined' || (hexString != null && hexString.length !== 24)) {
-            throw new BSONTypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');
+            throw new BSONError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');
         }
         return new ObjectId(ByteUtils.fromHex(hexString));
     }
@@ -2191,7 +2181,14 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
         case 'boolean':
             return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 1);
         case 'object':
-            if (value == null || value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
+            if (value != null &&
+                typeof value._bsontype === 'string' &&
+                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
+                throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+            }
+            else if (value == null ||
+                value['_bsontype'] === 'MinKey' ||
+                value['_bsontype'] === 'MaxKey') {
                 return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;
             }
             else if (value['_bsontype'] === 'ObjectId') {
@@ -2349,7 +2346,7 @@ class BSONRegExp {
         if ('$regularExpression' in doc) {
             return new BSONRegExp(doc.$regularExpression.pattern, BSONRegExp.parseOptions(doc.$regularExpression.options));
         }
-        throw new BSONTypeError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
+        throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
     }
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
@@ -2541,9 +2538,16 @@ function deserializeObject(buffer, index, options, isArray = false) {
     const fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];
     const raw = options['raw'] == null ? false : options['raw'];
     const bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;
-    const promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
-    const promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
-    const promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
+    const promoteBuffers = options.promoteBuffers ?? false;
+    const promoteLongs = options.promoteLongs ?? true;
+    const promoteValues = options.promoteValues ?? true;
+    const useBigInt64 = options.useBigInt64 ?? false;
+    if (useBigInt64 && !promoteValues) {
+        throw new BSONError('Must either request bigint or Long for int64 deserialization');
+    }
+    if (useBigInt64 && !promoteLongs) {
+        throw new BSONError('Must either request bigint or Long for int64 deserialization');
+    }
     const validation = options.validation == null ? { utf8: true } : options.validation;
     let globalUTFValidation = true;
     let validationSetting;
@@ -2708,6 +2712,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             value = null;
         }
         else if (elementType === BSON_DATA_LONG) {
+            const dataview = BSONDataView.fromUint8Array(buffer.subarray(index, index + 8));
             const lowBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
@@ -2717,7 +2722,10 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
             const long = new Long(lowBits, highBits);
-            if (promoteLongs && promoteValues === true) {
+            if (useBigInt64) {
+                value = dataview.getBigInt64(0, true);
+            }
+            else if (promoteLongs && promoteValues === true) {
                 value =
                     long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
                         ? long.toNumber()
@@ -3039,6 +3047,16 @@ function serializeNumber(buffer, key, value, index) {
     index += bytes.byteLength;
     return index;
 }
+function serializeBigInt(buffer, key, value, index) {
+    buffer[index++] = BSON_DATA_LONG;
+    const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
+    index += numberOfWrittenBytes;
+    buffer[index++] = 0;
+    NUMBER_SPACE.setBigInt64(0, value, true);
+    buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
+    index += EIGHT_BYTE_VIEW_ON_NUMBER.byteLength;
+    return index;
+}
 function serializeNull(buffer, key, _, index) {
     buffer[index++] = BSON_DATA_NULL;
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
@@ -3078,7 +3096,7 @@ function serializeRegExp(buffer, key, value, index) {
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
     if (value.source && value.source.match(regexp) != null) {
-        throw Error('value ' + value.source + ' must not contain null bytes');
+        throw new BSONError('value ' + value.source + ' must not contain null bytes');
     }
     index = index + ByteUtils.encodeUTF8Into(buffer, value.source, index);
     buffer[index++] = 0x00;
@@ -3097,7 +3115,7 @@ function serializeBSONRegExp(buffer, key, value, index) {
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
     if (value.pattern.match(regexp) != null) {
-        throw Error('pattern ' + value.pattern + ' must not contain null bytes');
+        throw new BSONError('pattern ' + value.pattern + ' must not contain null bytes');
     }
     index = index + ByteUtils.encodeUTF8Into(buffer, value.pattern, index);
     buffer[index++] = 0x00;
@@ -3130,7 +3148,7 @@ function serializeObjectId(buffer, key, value, index) {
         buffer.set(value.id.subarray(0, 12), index);
     }
     else {
-        throw new BSONTypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
+        throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
     }
     return index + 12;
 }
@@ -3370,7 +3388,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 index = serializeNumber(buffer, key, value, index);
             }
             else if (typeof value === 'bigint') {
-                throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
+                index = serializeBigInt(buffer, key, value, index);
             }
             else if (typeof value === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
@@ -3393,7 +3411,8 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             else if (typeof value === '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')] == null) {
+            else if (typeof value === 'object' &&
+                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
                 throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
             }
             else if (value._bsontype === 'ObjectId') {
@@ -3433,7 +3452,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 index = serializeMinMax(buffer, key, value, index);
             }
             else if (typeof value._bsontype !== 'undefined') {
-                throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
             }
         }
     }
@@ -3446,18 +3465,21 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             if (done)
                 continue;
             const key = entry.value[0];
-            const value = entry.value[1];
+            let value = entry.value[1];
+            if (typeof value?.toBSON === 'function') {
+                value = value.toBSON();
+            }
             const type = typeof value;
             if (typeof key === 'string' && !ignoreKeys.has(key)) {
                 if (key.match(regexp) != null) {
-                    throw Error('key ' + key + ' must not contain null bytes');
+                    throw new BSONError('key ' + key + ' must not contain null bytes');
                 }
                 if (checkKeys) {
                     if ('$' === key[0]) {
-                        throw Error('key ' + key + " must not start with '$'");
+                        throw new BSONError('key ' + key + " must not start with '$'");
                     }
                     else if (~key.indexOf('.')) {
-                        throw Error('key ' + key + " must not contain '.'");
+                        throw new BSONError('key ' + key + " must not contain '.'");
                     }
                 }
             }
@@ -3467,8 +3489,8 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             else if (type === 'number') {
                 index = serializeNumber(buffer, key, value, index);
             }
-            else if (type === 'bigint' || isBigInt64Array(value) || isBigUInt64Array(value)) {
-                throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
+            else if (type === 'bigint') {
+                index = serializeBigInt(buffer, key, value, index);
             }
             else if (type === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
@@ -3488,7 +3510,8 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             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')] == null) {
+            else if (typeof value === 'object' &&
+                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
                 throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
             }
             else if (value._bsontype === 'ObjectId') {
@@ -3528,7 +3551,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 index = serializeMinMax(buffer, key, value, index);
             }
             else if (typeof value._bsontype !== 'undefined') {
-                throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
             }
         }
     }
@@ -3536,7 +3559,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
         if (typeof object?.toBSON === 'function') {
             object = object.toBSON();
             if (object != null && typeof object !== 'object') {
-                throw new BSONTypeError('toBSON function did not return an object');
+                throw new BSONError('toBSON function did not return an object');
             }
         }
         for (const key of Object.keys(object)) {
@@ -3547,14 +3570,14 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             const type = typeof value;
             if (typeof key === 'string' && !ignoreKeys.has(key)) {
                 if (key.match(regexp) != null) {
-                    throw Error('key ' + key + ' must not contain null bytes');
+                    throw new BSONError('key ' + key + ' must not contain null bytes');
                 }
                 if (checkKeys) {
                     if ('$' === key[0]) {
-                        throw Error('key ' + key + " must not start with '$'");
+                        throw new BSONError('key ' + key + " must not start with '$'");
                     }
                     else if (~key.indexOf('.')) {
-                        throw Error('key ' + key + " must not contain '.'");
+                        throw new BSONError('key ' + key + " must not contain '.'");
                     }
                 }
             }
@@ -3565,7 +3588,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 index = serializeNumber(buffer, key, value, index);
             }
             else if (type === 'bigint') {
-                throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
+                index = serializeBigInt(buffer, key, value, index);
             }
             else if (type === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
@@ -3589,7 +3612,8 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             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')] == null) {
+            else if (typeof value === 'object' &&
+                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
                 throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
             }
             else if (value._bsontype === 'ObjectId') {
@@ -3629,7 +3653,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 index = serializeMinMax(buffer, key, value, index);
             }
             else if (typeof value._bsontype !== 'undefined') {
-                throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
             }
         }
     }
@@ -3763,7 +3787,7 @@ function serializeValue(value, options) {
             const current = props[props.length - 1];
             const leadingSpace = ' '.repeat(leadingPart.length + alreadySeen.length / 2);
             const dashes = '-'.repeat(circularPart.length + (alreadySeen.length + current.length) / 2 - 1);
-            throw new BSONTypeError('Converting circular structure to EJSON:\n' +
+            throw new BSONError('Converting circular structure to EJSON:\n' +
                 `    ${leadingPart}${alreadySeen}${circularPart}${current}\n` +
                 `    ${leadingSpace}\\${dashes}/`);
         }
@@ -3856,7 +3880,7 @@ function serializeDocument(doc, options) {
     else if (doc != null &&
         typeof doc === 'object' &&
         typeof doc._bsontype === 'string' &&
-        doc[Symbol.for('@@mdb.bson.version')] == null) {
+        doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
         throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
     }
     else if (isBSONType(doc)) {
@@ -3864,7 +3888,7 @@ function serializeDocument(doc, options) {
         if (typeof outDoc.toExtendedJSON !== 'function') {
             const mapper = BSON_TYPE_MAPPINGS[doc._bsontype];
             if (!mapper) {
-                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + doc._bsontype);
+                throw new BSONError('Unrecognized or invalid _bsontype: ' + doc._bsontype);
             }
             outDoc = mapper(outDoc);
         }
@@ -3996,7 +4020,6 @@ var bson = /*#__PURE__*/Object.freeze({
     calculateObjectSize: calculateObjectSize,
     deserializeStream: deserializeStream,
     BSONError: BSONError,
-    BSONTypeError: BSONTypeError,
     BSONType: BSONType,
     EJSON: EJSON
 });
@@ -4006,7 +4029,6 @@ exports.BSONError = BSONError;
 exports.BSONRegExp = BSONRegExp;
 exports.BSONSymbol = BSONSymbol;
 exports.BSONType = BSONType;
-exports.BSONTypeError = BSONTypeError;
 exports.Binary = Binary;
 exports.Code = Code;
 exports.DBRef = DBRef;