bson 5.0.0-alpha.1 → 5.0.0-alpha.3

package/lib/bson.bundle.js

@@ -1,20 +1,86 @@
 var BSON = (function (exports) {
 'use strict';
 
+const BSON_MAJOR_VERSION = 5;
+const BSON_INT32_MAX = 0x7fffffff;
+const BSON_INT32_MIN = -0x80000000;
+const BSON_INT64_MAX = Math.pow(2, 63) - 1;
+const BSON_INT64_MIN = -Math.pow(2, 63);
+const JS_INT_MAX = Math.pow(2, 53);
+const JS_INT_MIN = -Math.pow(2, 53);
+const BSON_DATA_NUMBER = 1;
+const BSON_DATA_STRING = 2;
+const BSON_DATA_OBJECT = 3;
+const BSON_DATA_ARRAY = 4;
+const BSON_DATA_BINARY = 5;
+const BSON_DATA_UNDEFINED = 6;
+const BSON_DATA_OID = 7;
+const BSON_DATA_BOOLEAN = 8;
+const BSON_DATA_DATE = 9;
+const BSON_DATA_NULL = 10;
+const BSON_DATA_REGEXP = 11;
+const BSON_DATA_DBPOINTER = 12;
+const BSON_DATA_CODE = 13;
+const BSON_DATA_SYMBOL = 14;
+const BSON_DATA_CODE_W_SCOPE = 15;
+const BSON_DATA_INT = 16;
+const BSON_DATA_TIMESTAMP = 17;
+const BSON_DATA_LONG = 18;
+const BSON_DATA_DECIMAL128 = 19;
+const BSON_DATA_MIN_KEY = 0xff;
+const BSON_DATA_MAX_KEY = 0x7f;
+const BSON_BINARY_SUBTYPE_DEFAULT = 0;
+const BSON_BINARY_SUBTYPE_UUID_NEW = 4;
+const BSONType = Object.freeze({
+    double: 1,
+    string: 2,
+    object: 3,
+    array: 4,
+    binData: 5,
+    undefined: 6,
+    objectId: 7,
+    bool: 8,
+    date: 9,
+    null: 10,
+    regex: 11,
+    dbPointer: 12,
+    javascript: 13,
+    symbol: 14,
+    javascriptWithScope: 15,
+    int: 16,
+    timestamp: 17,
+    long: 18,
+    decimal: 19,
+    minKey: -1,
+    maxKey: 127
+});
+
 class BSONError extends Error {
-    constructor(message) {
-        super(message);
+    get bsonError() {
+        return true;
     }
     get name() {
         return 'BSONError';
     }
-}
-class BSONTypeError extends TypeError {
     constructor(message) {
         super(message);
     }
+    static isBSONError(value) {
+        return (value != null &&
+            typeof value === 'object' &&
+            'bsonError' in value &&
+            value.bsonError === true &&
+            'name' in value &&
+            'message' in value &&
+            'stack' in value);
+    }
+}
+class BSONVersionError extends BSONError {
     get name() {
-        return 'BSONTypeError';
+        return 'BSONVersionError';
+    }
+    constructor() {
+        super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.0 or later`);
     }
 }
 
@@ -213,7 +279,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);
@@ -237,12 +303,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]';
 }
@@ -253,74 +313,24 @@ function isDate(d) {
     return Object.prototype.toString.call(d) === '[object Date]';
 }
 
-const BSON_MAJOR_VERSION = 5;
-const BSON_INT32_MAX = 0x7fffffff;
-const BSON_INT32_MIN = -0x80000000;
-const BSON_INT64_MAX = Math.pow(2, 63) - 1;
-const BSON_INT64_MIN = -Math.pow(2, 63);
-const JS_INT_MAX = Math.pow(2, 53);
-const JS_INT_MIN = -Math.pow(2, 53);
-const BSON_DATA_NUMBER = 1;
-const BSON_DATA_STRING = 2;
-const BSON_DATA_OBJECT = 3;
-const BSON_DATA_ARRAY = 4;
-const BSON_DATA_BINARY = 5;
-const BSON_DATA_UNDEFINED = 6;
-const BSON_DATA_OID = 7;
-const BSON_DATA_BOOLEAN = 8;
-const BSON_DATA_DATE = 9;
-const BSON_DATA_NULL = 10;
-const BSON_DATA_REGEXP = 11;
-const BSON_DATA_DBPOINTER = 12;
-const BSON_DATA_CODE = 13;
-const BSON_DATA_SYMBOL = 14;
-const BSON_DATA_CODE_W_SCOPE = 15;
-const BSON_DATA_INT = 16;
-const BSON_DATA_TIMESTAMP = 17;
-const BSON_DATA_LONG = 18;
-const BSON_DATA_DECIMAL128 = 19;
-const BSON_DATA_MIN_KEY = 0xff;
-const BSON_DATA_MAX_KEY = 0x7f;
-const BSON_BINARY_SUBTYPE_DEFAULT = 0;
-const BSON_BINARY_SUBTYPE_UUID_NEW = 4;
-const BSONType = Object.freeze({
-    double: 1,
-    string: 2,
-    object: 3,
-    array: 4,
-    binData: 5,
-    undefined: 6,
-    objectId: 7,
-    bool: 8,
-    date: 9,
-    null: 10,
-    regex: 11,
-    dbPointer: 12,
-    javascript: 13,
-    symbol: 14,
-    javascriptWithScope: 15,
-    int: 16,
-    timestamp: 17,
-    long: 18,
-    decimal: 19,
-    minKey: -1,
-    maxKey: 127
-});
+class BSONValue {
+    get [Symbol.for('@@mdb.bson.version')]() {
+        return BSON_MAJOR_VERSION;
+    }
+}
 
-class Binary {
+class Binary extends BSONValue {
     get _bsontype() {
         return 'Binary';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(buffer, subType) {
+        super();
         if (!(buffer == null) &&
             !(typeof buffer === 'string') &&
             !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) {
@@ -342,10 +352,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);
@@ -357,7 +367,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;
@@ -461,7 +471,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);
     }
@@ -485,9 +495,6 @@ Binary.SUBTYPE_COLUMN = 7;
 Binary.SUBTYPE_USER_DEFINED = 128;
 const UUID_BYTE_LENGTH = 16;
 class UUID extends Binary {
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(input) {
         let bytes;
         let hexStr;
@@ -505,7 +512,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;
@@ -592,14 +599,12 @@ class UUID extends Binary {
     }
 }
 
-class Code {
+class Code extends BSONValue {
     get _bsontype() {
         return 'Code';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(code, scope) {
+        super();
         this.code = code.toString();
         this.scope = scope ?? null;
     }
@@ -636,14 +641,12 @@ function isDBRefLike(value) {
         typeof value.$ref === 'string' &&
         (!('$db' in value) || ('$db' in value && typeof value.$db === 'string')));
 }
-class DBRef {
+class DBRef extends BSONValue {
     get _bsontype() {
         return 'DBRef';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(collection, oid, db, fields) {
+        super();
         const parts = collection.split('.');
         if (parts.length === 2) {
             db = parts.shift();
@@ -712,17 +715,17 @@ const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
 const TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
 const INT_CACHE = {};
 const UINT_CACHE = {};
-class Long {
+const MAX_INT64_STRING_LENGTH = 20;
+const DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/;
+class Long extends BSONValue {
     get _bsontype() {
         return 'Long';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     get __isLong__() {
         return true;
     }
     constructor(low = 0, high, unsigned) {
+        super();
         if (typeof low === 'bigint') {
             Object.assign(this, Long.fromBigInt(low, !!high));
         }
@@ -789,7 +792,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') {
@@ -800,10 +803,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();
         }
@@ -899,7 +902,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 &&
@@ -1254,7 +1257,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()) {
@@ -1305,8 +1308,22 @@ class Long {
         return { $numberLong: this.toString() };
     }
     static fromExtendedJSON(doc, options) {
-        const result = Long.fromString(doc.$numberLong);
-        return options && options.relaxed ? result.toNumber() : result;
+        const { useBigInt64 = false, relaxed = true } = { ...options };
+        if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) {
+            throw new BSONError('$numberLong string is too long');
+        }
+        if (!DECIMAL_REG_EX.test(doc.$numberLong)) {
+            throw new BSONError(`$numberLong string "${doc.$numberLong}" is in an invalid format`);
+        }
+        if (useBigInt64) {
+            const bigIntResult = BigInt(doc.$numberLong);
+            return BigInt.asIntN(64, bigIntResult);
+        }
+        const longResult = Long.fromString(doc.$numberLong);
+        if (relaxed) {
+            return longResult.toNumber();
+        }
+        return longResult;
     }
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
@@ -1398,27 +1415,25 @@ 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 {
+class Decimal128 extends BSONValue {
     get _bsontype() {
         return 'Decimal128';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(bytes) {
+        super();
         if (typeof bytes === 'string') {
             this.bytes = Decimal128.fromString(bytes).bytes;
         }
         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) {
@@ -1442,13 +1457,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];
@@ -1500,7 +1515,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])
@@ -1829,14 +1844,12 @@ class Decimal128 {
     }
 }
 
-class Double {
+class Double extends BSONValue {
     get _bsontype() {
         return 'Double';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(value) {
+        super();
         if (value instanceof Number) {
             value = value.valueOf();
         }
@@ -1856,19 +1869,11 @@ class Double {
             return this.value;
         }
         if (Object.is(Math.sign(this.value), -0)) {
-            return { $numberDouble: `-${this.value.toFixed(1)}` };
+            return { $numberDouble: '-0.0' };
         }
-        let $numberDouble;
-        if (Number.isInteger(this.value)) {
-            $numberDouble = this.value.toFixed(1);
-            if ($numberDouble.length >= 13) {
-                $numberDouble = this.value.toExponential(13).toUpperCase();
-            }
-        }
-        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);
@@ -1883,14 +1888,12 @@ class Double {
     }
 }
 
-class Int32 {
+class Int32 extends BSONValue {
     get _bsontype() {
         return 'Int32';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(value) {
+        super();
         if (value instanceof Number) {
             value = value.valueOf();
         }
@@ -1921,13 +1924,10 @@ class Int32 {
     }
 }
 
-class MaxKey {
+class MaxKey extends BSONValue {
     get _bsontype() {
         return 'MaxKey';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     toExtendedJSON() {
         return { $maxKey: 1 };
     }
@@ -1942,13 +1942,10 @@ class MaxKey {
     }
 }
 
-class MinKey {
+class MinKey extends BSONValue {
     get _bsontype() {
         return 'MinKey';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     toExtendedJSON() {
         return { $minKey: 1 };
     }
@@ -1966,18 +1963,16 @@ class MinKey {
 const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
 let PROCESS_UNIQUE = null;
 const kId = Symbol('id');
-class ObjectId {
+class ObjectId extends BSONValue {
     get _bsontype() {
         return 'ObjectId';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(inputId) {
+        super();
         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());
@@ -2002,18 +1997,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);
@@ -2115,7 +2110,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));
     }
@@ -2192,10 +2187,15 @@ 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 BSONVersionError();
+            }
+            else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
                 return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;
             }
-            else if (value['_bsontype'] === 'ObjectId') {
+            else if (value._bsontype === 'ObjectId') {
                 return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (12 + 1);
             }
             else if (value instanceof Date || isDate(value)) {
@@ -2206,15 +2206,15 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
                 isAnyArrayBuffer(value)) {
                 return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 4 + 1) + value.byteLength);
             }
-            else if (value['_bsontype'] === 'Long' ||
-                value['_bsontype'] === 'Double' ||
-                value['_bsontype'] === 'Timestamp') {
+            else if (value._bsontype === 'Long' ||
+                value._bsontype === 'Double' ||
+                value._bsontype === 'Timestamp') {
                 return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
             }
-            else if (value['_bsontype'] === 'Decimal128') {
+            else if (value._bsontype === 'Decimal128') {
                 return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (16 + 1);
             }
-            else if (value['_bsontype'] === 'Code') {
+            else if (value._bsontype === 'Code') {
                 if (value.scope != null && Object.keys(value.scope).length > 0) {
                     return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
                         1 +
@@ -2232,7 +2232,7 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
                         1);
                 }
             }
-            else if (value['_bsontype'] === 'Binary') {
+            else if (value._bsontype === 'Binary') {
                 const binary = value;
                 if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
                     return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
@@ -2242,14 +2242,14 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
                     return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1));
                 }
             }
-            else if (value['_bsontype'] === 'Symbol') {
+            else if (value._bsontype === 'Symbol') {
                 return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
                     ByteUtils.utf8ByteLength(value.value) +
                     4 +
                     1 +
                     1);
             }
-            else if (value['_bsontype'] === 'DBRef') {
+            else if (value._bsontype === 'DBRef') {
                 const ordered_values = Object.assign({
                     $ref: value.collection,
                     $id: value.oid
@@ -2271,7 +2271,7 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
                     (value.multiline ? 1 : 0) +
                     1);
             }
-            else if (value['_bsontype'] === 'BSONRegExp') {
+            else if (value._bsontype === 'BSONRegExp') {
                 return ((name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
                     1 +
                     ByteUtils.utf8ByteLength(value.pattern) +
@@ -2299,14 +2299,12 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
 function alphabetize(str) {
     return str.split('').sort().join('');
 }
-class BSONRegExp {
+class BSONRegExp extends BSONValue {
     get _bsontype() {
         return 'BSONRegExp';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(pattern, options) {
+        super();
         this.pattern = pattern;
         this.options = alphabetize(options ?? '');
         if (this.pattern.indexOf('\x00') !== -1) {
@@ -2350,7 +2348,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();
@@ -2360,14 +2358,12 @@ class BSONRegExp {
     }
 }
 
-class BSONSymbol {
+class BSONSymbol extends BSONValue {
     get _bsontype() {
         return 'BSONSymbol';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(value) {
+        super();
         this.value = value;
     }
     valueOf() {
@@ -2398,9 +2394,6 @@ class Timestamp extends LongWithoutOverridesClass {
     get _bsontype() {
         return 'Timestamp';
     }
-    get [Symbol.for('@@mdb.bson.version')]() {
-        return BSON_MAJOR_VERSION;
-    }
     constructor(low) {
         if (low == null) {
             super(0, 0, true);
@@ -2542,9 +2535,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;
@@ -2709,6 +2709,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) |
@@ -2718,7 +2719,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()
@@ -3040,6 +3044,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);
@@ -3079,7 +3093,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;
@@ -3098,7 +3112,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;
@@ -3131,7 +3145,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;
 }
@@ -3371,7 +3385,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);
@@ -3394,8 +3408,9 @@ 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) {
-                throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+            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);
@@ -3434,7 +3449,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)}`);
             }
         }
     }
@@ -3447,18 +3462,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 '.'");
                     }
                 }
             }
@@ -3468,8 +3486,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);
@@ -3489,8 +3507,9 @@ 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) {
-                throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+            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);
@@ -3529,7 +3548,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)}`);
             }
         }
     }
@@ -3537,7 +3556,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)) {
@@ -3548,14 +3567,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 '.'");
                     }
                 }
             }
@@ -3566,7 +3585,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);
@@ -3590,8 +3609,9 @@ 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) {
-                throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+            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);
@@ -3630,7 +3650,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)}`);
             }
         }
     }
@@ -3667,14 +3687,19 @@ const keysToCodecs = {
 };
 function deserializeValue(value, options = {}) {
     if (typeof value === 'number') {
+        const in32BitRange = value <= BSON_INT32_MAX && value >= BSON_INT32_MIN;
+        const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN;
         if (options.relaxed || options.legacy) {
             return value;
         }
         if (Number.isInteger(value) && !Object.is(value, -0)) {
-            if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
+            if (in32BitRange) {
                 return new Int32(value);
             }
-            if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {
+            if (in64BitRange) {
+                if (options.useBigInt64) {
+                    return BigInt(value);
+                }
                 return Long.fromNumber(value);
             }
         }
@@ -3764,7 +3789,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}/`);
         }
@@ -3796,6 +3821,12 @@ function serializeValue(value, options) {
         }
         return { $numberDouble: Object.is(value, -0) ? '-0.0' : value.toString() };
     }
+    if (typeof value === 'bigint') {
+        if (!options.relaxed) {
+            return { $numberLong: BigInt.asIntN(64, value).toString() };
+        }
+        return Number(BigInt.asIntN(64, value));
+    }
     if (value instanceof RegExp || isRegExp(value)) {
         let flags = value.flags;
         if (flags === undefined) {
@@ -3857,15 +3888,15 @@ function serializeDocument(doc, options) {
     else if (doc != null &&
         typeof doc === 'object' &&
         typeof doc._bsontype === 'string' &&
-        doc[Symbol.for('@@mdb.bson.version')] == null) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+        doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
+        throw new BSONVersionError();
     }
     else if (isBSONType(doc)) {
         let outDoc = doc;
         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);
         }
@@ -3882,11 +3913,16 @@ function serializeDocument(doc, options) {
     }
 }
 function parse(text, options) {
+    const ejsonOptions = {
+        useBigInt64: options?.useBigInt64 ?? false,
+        relaxed: options?.relaxed ?? true,
+        legacy: options?.legacy ?? false
+    };
     return JSON.parse(text, (key, value) => {
         if (key.indexOf('\x00') !== -1) {
             throw new BSONError(`BSON Document field names cannot contain null bytes, found: ${JSON.stringify(key)}`);
         }
-        return deserializeValue(value, { relaxed: true, legacy: false, ...options });
+        return deserializeValue(value, ejsonOptions);
     });
 }
 function stringify(value, replacer, space, options) {
@@ -3996,8 +4032,9 @@ serializeWithBufferAndIndex: serializeWithBufferAndIndex,
 deserialize: deserialize,
 calculateObjectSize: calculateObjectSize,
 deserializeStream: deserializeStream,
+BSONValue: BSONValue,
 BSONError: BSONError,
-BSONTypeError: BSONTypeError,
+BSONVersionError: BSONVersionError,
 BSONType: BSONType,
 EJSON: EJSON
 });
@@ -4007,7 +4044,8 @@ exports.BSONError = BSONError;
 exports.BSONRegExp = BSONRegExp;
 exports.BSONSymbol = BSONSymbol;
 exports.BSONType = BSONType;
-exports.BSONTypeError = BSONTypeError;
+exports.BSONValue = BSONValue;
+exports.BSONVersionError = BSONVersionError;
 exports.Binary = Binary;
 exports.Code = Code;
 exports.DBRef = DBRef;