bson 4.6.3 → 4.7.0

package/dist/bson.bundle.js

@@ -2131,11 +2131,11 @@ var BSON = (function (exports) {
 	}
 	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
 	function getGlobal() {
-	    // eslint-disable-next-line no-undef
 	    return (checkForMath(typeof globalThis === 'object' && globalThis) ||
 	        checkForMath(typeof window === 'object' && window) ||
 	        checkForMath(typeof self === 'object' && self) ||
 	        checkForMath(typeof global === 'object' && global) ||
+	        // eslint-disable-next-line @typescript-eslint/no-implied-eval
 	        Function('return this')());
 	}
 
@@ -2161,27 +2161,20 @@ var BSON = (function (exports) {
 	    return result;
 	};
 	var detectRandomBytes = function () {
-	    if (typeof window !== 'undefined') {
-	        // browser crypto implementation(s)
-	        var target_1 = window.crypto || window.msCrypto; // allow for IE11
-	        if (target_1 && target_1.getRandomValues) {
-	            return function (size) { return target_1.getRandomValues(buffer_1.alloc(size)); };
+	    {
+	        if (typeof window !== 'undefined') {
+	            // browser crypto implementation(s)
+	            var target_1 = window.crypto || window.msCrypto; // allow for IE11
+	            if (target_1 && target_1.getRandomValues) {
+	                return function (size) { return target_1.getRandomValues(buffer_1.alloc(size)); };
+	            }
 	        }
+	        if (typeof global !== 'undefined' && global.crypto && global.crypto.getRandomValues) {
+	            // allow for RN packages such as https://www.npmjs.com/package/react-native-get-random-values to populate global
+	            return function (size) { return global.crypto.getRandomValues(buffer_1.alloc(size)); };
+	        }
+	        return insecureRandomBytes;
 	    }
-	    if (typeof global !== 'undefined' && global.crypto && global.crypto.getRandomValues) {
-	        // allow for RN packages such as https://www.npmjs.com/package/react-native-get-random-values to populate global
-	        return function (size) { return global.crypto.getRandomValues(buffer_1.alloc(size)); };
-	    }
-	    var requiredRandomBytes;
-	    try {
-	        // eslint-disable-next-line @typescript-eslint/no-var-requires
-	        requiredRandomBytes = require('crypto').randomBytes;
-	    }
-	    catch (e) {
-	        // keep the fallback
-	    }
-	    // NOTE: in transpiled cases the above require might return null/undefined
-	    return requiredRandomBytes || insecureRandomBytes;
 	};
 	var randomBytes = detectRandomBytes();
 	function isAnyArrayBuffer(value) {
@@ -2275,174 +2268,84 @@ var BSON = (function (exports) {
 	        : buffer.toString('hex');
 	};
 
-	var BYTE_LENGTH = 16;
-	var kId$1 = Symbol('id');
+	/** @internal */
+	var BSON_INT32_MAX$1 = 0x7fffffff;
+	/** @internal */
+	var BSON_INT32_MIN$1 = -0x80000000;
+	/** @internal */
+	var BSON_INT64_MAX$1 = Math.pow(2, 63) - 1;
+	/** @internal */
+	var BSON_INT64_MIN$1 = -Math.pow(2, 63);
 	/**
-	 * A class representation of the BSON UUID type.
-	 * @public
+	 * Any integer up to 2^53 can be precisely represented by a double.
+	 * @internal
 	 */
-	var UUID = /** @class */ (function () {
-	    /**
-	     * Create an UUID type
-	     *
-	     * @param input - Can be a 32 or 36 character hex string (dashes excluded/included) or a 16 byte binary Buffer.
-	     */
-	    function UUID(input) {
-	        if (typeof input === 'undefined') {
-	            // The most common use case (blank id, new UUID() instance)
-	            this.id = UUID.generate();
-	        }
-	        else if (input instanceof UUID) {
-	            this[kId$1] = buffer_1.from(input.id);
-	            this.__id = input.__id;
-	        }
-	        else if (ArrayBuffer.isView(input) && input.byteLength === BYTE_LENGTH) {
-	            this.id = ensureBuffer(input);
-	        }
-	        else if (typeof input === 'string') {
-	            this.id = 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).');
-	        }
-	    }
-	    Object.defineProperty(UUID.prototype, "id", {
-	        /**
-	         * The UUID bytes
-	         * @readonly
-	         */
-	        get: function () {
-	            return this[kId$1];
-	        },
-	        set: function (value) {
-	            this[kId$1] = value;
-	            if (UUID.cacheHexString) {
-	                this.__id = bufferToUuidHexString(value);
-	            }
-	        },
-	        enumerable: false,
-	        configurable: true
-	    });
-	    /**
-	     * Generate a 16 byte uuid v4 buffer used in UUIDs
-	     */
-	    /**
-	     * Returns the UUID id as a 32 or 36 character hex string representation, excluding/including dashes (defaults to 36 character dash separated)
-	     * @param includeDashes - should the string exclude dash-separators.
-	     * */
-	    UUID.prototype.toHexString = function (includeDashes) {
-	        if (includeDashes === void 0) { includeDashes = true; }
-	        if (UUID.cacheHexString && this.__id) {
-	            return this.__id;
-	        }
-	        var uuidHexString = bufferToUuidHexString(this.id, includeDashes);
-	        if (UUID.cacheHexString) {
-	            this.__id = uuidHexString;
-	        }
-	        return uuidHexString;
-	    };
-	    /**
-	     * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.
-	     */
-	    UUID.prototype.toString = function (encoding) {
-	        return encoding ? this.id.toString(encoding) : this.toHexString();
-	    };
-	    /**
-	     * Converts the id into its JSON string representation.
-	     * A 36 character (dashes included) hex string in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-	     */
-	    UUID.prototype.toJSON = function () {
-	        return this.toHexString();
-	    };
-	    /**
-	     * Compares the equality of this UUID with `otherID`.
-	     *
-	     * @param otherId - UUID instance to compare against.
-	     */
-	    UUID.prototype.equals = function (otherId) {
-	        if (!otherId) {
-	            return false;
-	        }
-	        if (otherId instanceof UUID) {
-	            return otherId.id.equals(this.id);
-	        }
-	        try {
-	            return new UUID(otherId).id.equals(this.id);
-	        }
-	        catch (_a) {
-	            return false;
-	        }
-	    };
-	    /**
-	     * Creates a Binary instance from the current UUID.
-	     */
-	    UUID.prototype.toBinary = function () {
-	        return new Binary(this.id, Binary.SUBTYPE_UUID);
-	    };
-	    /**
-	     * Generates a populated buffer containing a v4 uuid
-	     */
-	    UUID.generate = function () {
-	        var bytes = randomBytes(BYTE_LENGTH);
-	        // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-	        // Kindly borrowed from https://github.com/uuidjs/uuid/blob/master/src/v4.js
-	        bytes[6] = (bytes[6] & 0x0f) | 0x40;
-	        bytes[8] = (bytes[8] & 0x3f) | 0x80;
-	        return buffer_1.from(bytes);
-	    };
-	    /**
-	     * Checks if a value is a valid bson UUID
-	     * @param input - UUID, string or Buffer to validate.
-	     */
-	    UUID.isValid = function (input) {
-	        if (!input) {
-	            return false;
-	        }
-	        if (input instanceof UUID) {
-	            return true;
-	        }
-	        if (typeof input === 'string') {
-	            return uuidValidateString(input);
-	        }
-	        if (isUint8Array(input)) {
-	            // check for length & uuid version (https://tools.ietf.org/html/rfc4122#section-4.1.3)
-	            if (input.length !== BYTE_LENGTH) {
-	                return false;
-	            }
-	            try {
-	                // get this byte as hex:             xxxxxxxx-xxxx-XXxx-xxxx-xxxxxxxxxxxx
-	                // check first part as uuid version: xxxxxxxx-xxxx-Xxxx-xxxx-xxxxxxxxxxxx
-	                return parseInt(input[6].toString(16)[0], 10) === Binary.SUBTYPE_UUID;
-	            }
-	            catch (_a) {
-	                return false;
-	            }
-	        }
-	        return false;
-	    };
-	    /**
-	     * Creates an UUID from a hex string representation of an UUID.
-	     * @param hexString - 32 or 36 character hex string (dashes excluded/included).
-	     */
-	    UUID.createFromHexString = function (hexString) {
-	        var buffer = uuidHexStringToBuffer(hexString);
-	        return new UUID(buffer);
-	    };
-	    /**
-	     * Converts to a string representation of this Id.
-	     *
-	     * @returns return the 36 character hex string representation.
-	     * @internal
-	     */
-	    UUID.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
-	        return this.inspect();
-	    };
-	    UUID.prototype.inspect = function () {
-	        return "new UUID(\"" + this.toHexString() + "\")";
-	    };
-	    return UUID;
-	}());
-	Object.defineProperty(UUID.prototype, '_bsontype', { value: 'UUID' });
+	var JS_INT_MAX = Math.pow(2, 53);
+	/**
+	 * Any integer down to -2^53 can be precisely represented by a double.
+	 * @internal
+	 */
+	var JS_INT_MIN = -Math.pow(2, 53);
+	/** Number BSON Type @internal */
+	var BSON_DATA_NUMBER = 1;
+	/** String BSON Type @internal */
+	var BSON_DATA_STRING = 2;
+	/** Object BSON Type @internal */
+	var BSON_DATA_OBJECT = 3;
+	/** Array BSON Type @internal */
+	var BSON_DATA_ARRAY = 4;
+	/** Binary BSON Type @internal */
+	var BSON_DATA_BINARY = 5;
+	/** Binary BSON Type @internal */
+	var BSON_DATA_UNDEFINED = 6;
+	/** ObjectId BSON Type @internal */
+	var BSON_DATA_OID = 7;
+	/** Boolean BSON Type @internal */
+	var BSON_DATA_BOOLEAN = 8;
+	/** Date BSON Type @internal */
+	var BSON_DATA_DATE = 9;
+	/** null BSON Type @internal */
+	var BSON_DATA_NULL = 10;
+	/** RegExp BSON Type @internal */
+	var BSON_DATA_REGEXP = 11;
+	/** Code BSON Type @internal */
+	var BSON_DATA_DBPOINTER = 12;
+	/** Code BSON Type @internal */
+	var BSON_DATA_CODE = 13;
+	/** Symbol BSON Type @internal */
+	var BSON_DATA_SYMBOL = 14;
+	/** Code with Scope BSON Type @internal */
+	var BSON_DATA_CODE_W_SCOPE = 15;
+	/** 32 bit Integer BSON Type @internal */
+	var BSON_DATA_INT = 16;
+	/** Timestamp BSON Type @internal */
+	var BSON_DATA_TIMESTAMP = 17;
+	/** Long BSON Type @internal */
+	var BSON_DATA_LONG = 18;
+	/** Decimal128 BSON Type @internal */
+	var BSON_DATA_DECIMAL128 = 19;
+	/** MinKey BSON Type @internal */
+	var BSON_DATA_MIN_KEY = 0xff;
+	/** MaxKey BSON Type @internal */
+	var BSON_DATA_MAX_KEY = 0x7f;
+	/** Binary Default Type @internal */
+	var BSON_BINARY_SUBTYPE_DEFAULT = 0;
+	/** Binary Function Type @internal */
+	var BSON_BINARY_SUBTYPE_FUNCTION = 1;
+	/** Binary Byte Array Type @internal */
+	var BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
+	/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */
+	var BSON_BINARY_SUBTYPE_UUID = 3;
+	/** Binary UUID Type @internal */
+	var BSON_BINARY_SUBTYPE_UUID_NEW = 4;
+	/** Binary MD5 Type @internal */
+	var BSON_BINARY_SUBTYPE_MD5 = 5;
+	/** Encrypted BSON type @internal */
+	var BSON_BINARY_SUBTYPE_ENCRYPTED = 6;
+	/** Column BSON type @internal */
+	var BSON_BINARY_SUBTYPE_COLUMN = 7;
+	/** Binary User Defined Type @internal */
+	var BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
 
 	/**
 	 * A class representation of the BSON Binary type.
@@ -2451,6 +2354,13 @@ var BSON = (function (exports) {
 	 */
 	var Binary = /** @class */ (function () {
 	    /**
+	     * Create a new Binary instance.
+	     *
+	     * This constructor can accept a string as its first argument. In this case,
+	     * this string will be encoded using ISO-8859-1, **not** using UTF-8.
+	     * This is almost certainly not what you want. Use `new Binary(Buffer.from(string))`
+	     * instead to convert the string to a Buffer using UTF-8 first.
+	     *
 	     * @param buffer - a buffer object containing the binary data.
 	     * @param subType - the option binary type.
 	     */
@@ -2610,7 +2520,7 @@ var BSON = (function (exports) {
 	        if (this.sub_type === Binary.SUBTYPE_UUID) {
 	            return new UUID(this.buffer.slice(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.");
+	        throw new BSONError("Binary sub_type \"".concat(this.sub_type, "\" is not supported for converting to UUID. Only \"").concat(Binary.SUBTYPE_UUID, "\" is currently supported."));
 	    };
 	    /** @internal */
 	    Binary.fromExtendedJSON = function (doc, options) {
@@ -2634,9 +2544,9 @@ var BSON = (function (exports) {
 	            data = uuidHexStringToBuffer(doc.$uuid);
 	        }
 	        if (!data) {
-	            throw new BSONTypeError("Unexpected Binary Extended JSON format " + JSON.stringify(doc));
+	            throw new BSONTypeError("Unexpected Binary Extended JSON format ".concat(JSON.stringify(doc)));
 	        }
-	        return new Binary(data, type);
+	        return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);
 	    };
 	    /** @internal */
 	    Binary.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
@@ -2644,7 +2554,7 @@ var BSON = (function (exports) {
 	    };
 	    Binary.prototype.inspect = function () {
 	        var asBuffer = this.value(true);
-	        return "new Binary(Buffer.from(\"" + asBuffer.toString('hex') + "\", \"hex\"), " + this.sub_type + ")";
+	        return "new Binary(Buffer.from(\"".concat(asBuffer.toString('hex'), "\", \"hex\"), ").concat(this.sub_type, ")");
 	    };
 	    /**
 	     * Binary default subtype
@@ -2674,6 +2584,168 @@ var BSON = (function (exports) {
 	    return Binary;
 	}());
 	Object.defineProperty(Binary.prototype, '_bsontype', { value: 'Binary' });
+	var UUID_BYTE_LENGTH = 16;
+	/**
+	 * A class representation of the BSON UUID type.
+	 * @public
+	 */
+	var UUID = /** @class */ (function (_super) {
+	    __extends(UUID, _super);
+	    /**
+	     * Create an UUID type
+	     *
+	     * @param input - Can be a 32 or 36 character hex string (dashes excluded/included) or a 16 byte binary Buffer.
+	     */
+	    function UUID(input) {
+	        var _this = this;
+	        var bytes;
+	        var hexStr;
+	        if (input == null) {
+	            bytes = UUID.generate();
+	        }
+	        else if (input instanceof UUID) {
+	            bytes = buffer_1.from(input.buffer);
+	            hexStr = input.__id;
+	        }
+	        else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
+	            bytes = ensureBuffer(input);
+	        }
+	        else if (typeof input === 'string') {
+	            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).');
+	        }
+	        _this = _super.call(this, bytes, BSON_BINARY_SUBTYPE_UUID_NEW) || this;
+	        _this.__id = hexStr;
+	        return _this;
+	    }
+	    Object.defineProperty(UUID.prototype, "id", {
+	        /**
+	         * The UUID bytes
+	         * @readonly
+	         */
+	        get: function () {
+	            return this.buffer;
+	        },
+	        set: function (value) {
+	            this.buffer = value;
+	            if (UUID.cacheHexString) {
+	                this.__id = bufferToUuidHexString(value);
+	            }
+	        },
+	        enumerable: false,
+	        configurable: true
+	    });
+	    /**
+	     * Returns the UUID id as a 32 or 36 character hex string representation, excluding/including dashes (defaults to 36 character dash separated)
+	     * @param includeDashes - should the string exclude dash-separators.
+	     * */
+	    UUID.prototype.toHexString = function (includeDashes) {
+	        if (includeDashes === void 0) { includeDashes = true; }
+	        if (UUID.cacheHexString && this.__id) {
+	            return this.__id;
+	        }
+	        var uuidHexString = bufferToUuidHexString(this.id, includeDashes);
+	        if (UUID.cacheHexString) {
+	            this.__id = uuidHexString;
+	        }
+	        return uuidHexString;
+	    };
+	    /**
+	     * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.
+	     */
+	    UUID.prototype.toString = function (encoding) {
+	        return encoding ? this.id.toString(encoding) : this.toHexString();
+	    };
+	    /**
+	     * Converts the id into its JSON string representation.
+	     * A 36 character (dashes included) hex string in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	     */
+	    UUID.prototype.toJSON = function () {
+	        return this.toHexString();
+	    };
+	    /**
+	     * Compares the equality of this UUID with `otherID`.
+	     *
+	     * @param otherId - UUID instance to compare against.
+	     */
+	    UUID.prototype.equals = function (otherId) {
+	        if (!otherId) {
+	            return false;
+	        }
+	        if (otherId instanceof UUID) {
+	            return otherId.id.equals(this.id);
+	        }
+	        try {
+	            return new UUID(otherId).id.equals(this.id);
+	        }
+	        catch (_a) {
+	            return false;
+	        }
+	    };
+	    /**
+	     * Creates a Binary instance from the current UUID.
+	     */
+	    UUID.prototype.toBinary = function () {
+	        return new Binary(this.id, Binary.SUBTYPE_UUID);
+	    };
+	    /**
+	     * Generates a populated buffer containing a v4 uuid
+	     */
+	    UUID.generate = function () {
+	        var bytes = randomBytes(UUID_BYTE_LENGTH);
+	        // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+	        // Kindly borrowed from https://github.com/uuidjs/uuid/blob/master/src/v4.js
+	        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+	        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+	        return buffer_1.from(bytes);
+	    };
+	    /**
+	     * Checks if a value is a valid bson UUID
+	     * @param input - UUID, string or Buffer to validate.
+	     */
+	    UUID.isValid = function (input) {
+	        if (!input) {
+	            return false;
+	        }
+	        if (input instanceof UUID) {
+	            return true;
+	        }
+	        if (typeof input === 'string') {
+	            return uuidValidateString(input);
+	        }
+	        if (isUint8Array(input)) {
+	            // check for length & uuid version (https://tools.ietf.org/html/rfc4122#section-4.1.3)
+	            if (input.length !== UUID_BYTE_LENGTH) {
+	                return false;
+	            }
+	            return (input[6] & 0xf0) === 0x40 && (input[8] & 0x80) === 0x80;
+	        }
+	        return false;
+	    };
+	    /**
+	     * Creates an UUID from a hex string representation of an UUID.
+	     * @param hexString - 32 or 36 character hex string (dashes excluded/included).
+	     */
+	    UUID.createFromHexString = function (hexString) {
+	        var buffer = uuidHexStringToBuffer(hexString);
+	        return new UUID(buffer);
+	    };
+	    /**
+	     * Converts to a string representation of this Id.
+	     *
+	     * @returns return the 36 character hex string representation.
+	     * @internal
+	     */
+	    UUID.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
+	        return this.inspect();
+	    };
+	    UUID.prototype.inspect = function () {
+	        return "new UUID(\"".concat(this.toHexString(), "\")");
+	    };
+	    return UUID;
+	}(Binary));
 
 	/**
 	 * A class representation of the BSON Code type.
@@ -2711,7 +2783,7 @@ var BSON = (function (exports) {
 	    };
 	    Code.prototype.inspect = function () {
 	        var codeJson = this.toJSON();
-	        return "new Code(\"" + codeJson.code + "\"" + (codeJson.scope ? ", " + JSON.stringify(codeJson.scope) : '') + ")";
+	        return "new Code(\"".concat(String(codeJson.code), "\"").concat(codeJson.scope ? ", ".concat(JSON.stringify(codeJson.scope)) : '', ")");
 	    };
 	    return Code;
 	}());
@@ -2802,7 +2874,7 @@ var BSON = (function (exports) {
 	    DBRef.prototype.inspect = function () {
 	        // NOTE: if OID is an ObjectId class it will just print the oid string.
 	        var oid = this.oid === undefined || this.oid.toString === undefined ? this.oid : this.oid.toString();
-	        return "new DBRef(\"" + this.namespace + "\", new ObjectId(\"" + oid + "\")" + (this.db ? ", \"" + this.db + "\"" : '') + ")";
+	        return "new DBRef(\"".concat(this.namespace, "\", new ObjectId(\"").concat(String(oid), "\")").concat(this.db ? ", \"".concat(this.db, "\"") : '', ")");
 	    };
 	    return DBRef;
 	}());
@@ -3039,7 +3111,6 @@ var BSON = (function (exports) {
 	    /**
 	     * Tests if the specified object is a Long.
 	     */
-	    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
 	    Long.isLong = function (value) {
 	        return isObjectLike(value) && value['__isLong__'] === true;
 	    };
@@ -3196,6 +3267,7 @@ var BSON = (function (exports) {
 	        // into the result, and subtract it from the remainder.  It is critical that
 	        // the approximate value is less than or equal to the real value so that the
 	        // remainder never becomes negative.
+	        // eslint-disable-next-line @typescript-eslint/no-this-alias
 	        rem = this;
 	        while (rem.gte(divisor)) {
 	            // Approximate the result of division. This may be a little greater or
@@ -3679,7 +3751,7 @@ var BSON = (function (exports) {
 	        return this.inspect();
 	    };
 	    Long.prototype.inspect = function () {
-	        return "new Long(\"" + this.toString() + "\"" + (this.unsigned ? ', true' : '') + ")";
+	        return "new Long(\"".concat(this.toString(), "\"").concat(this.unsigned ? ', true' : '', ")");
 	    };
 	    Long.TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
 	    /** Maximum unsigned value. */
@@ -3790,7 +3862,7 @@ var BSON = (function (exports) {
 	    return false;
 	}
 	function invalidErr(string, message) {
-	    throw new BSONTypeError("\"" + string + "\" is not a valid Decimal128 string - " + message);
+	    throw new BSONTypeError("\"".concat(string, "\" is not a valid Decimal128 string - ").concat(message));
 	}
 	/**
 	 * A class representation of the BSON Decimal128 type.
@@ -4288,35 +4360,35 @@ var BSON = (function (exports) {
 	            // as + or - 0 and using the non-scientific exponent (this is for the "invalid
 	            // representation should be treated as 0/-0" spec cases in decimal128-1.json)
 	            if (significand_digits > 34) {
-	                string.push("" + 0);
+	                string.push("".concat(0));
 	                if (exponent > 0)
-	                    string.push('E+' + exponent);
+	                    string.push("E+".concat(exponent));
 	                else if (exponent < 0)
-	                    string.push('E' + exponent);
+	                    string.push("E".concat(exponent));
 	                return string.join('');
 	            }
-	            string.push("" + significand[index++]);
+	            string.push("".concat(significand[index++]));
 	            significand_digits = significand_digits - 1;
 	            if (significand_digits) {
 	                string.push('.');
 	            }
 	            for (var i = 0; i < significand_digits; i++) {
-	                string.push("" + significand[index++]);
+	                string.push("".concat(significand[index++]));
 	            }
 	            // Exponent
 	            string.push('E');
 	            if (scientific_exponent > 0) {
-	                string.push('+' + scientific_exponent);
+	                string.push("+".concat(scientific_exponent));
 	            }
 	            else {
-	                string.push("" + scientific_exponent);
+	                string.push("".concat(scientific_exponent));
 	            }
 	        }
 	        else {
 	            // Regular format with no decimal place
 	            if (exponent >= 0) {
 	                for (var i = 0; i < significand_digits; i++) {
-	                    string.push("" + significand[index++]);
+	                    string.push("".concat(significand[index++]));
 	                }
 	            }
 	            else {
@@ -4324,7 +4396,7 @@ var BSON = (function (exports) {
 	                // non-zero digits before radix
 	                if (radix_position > 0) {
 	                    for (var i = 0; i < radix_position; i++) {
-	                        string.push("" + significand[index++]);
+	                        string.push("".concat(significand[index++]));
 	                    }
 	                }
 	                else {
@@ -4336,7 +4408,7 @@ var BSON = (function (exports) {
 	                    string.push('0');
 	                }
 	                for (var i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) {
-	                    string.push("" + significand[index++]);
+	                    string.push("".concat(significand[index++]));
 	                }
 	            }
 	        }
@@ -4358,7 +4430,7 @@ var BSON = (function (exports) {
 	        return this.inspect();
 	    };
 	    Decimal128.prototype.inspect = function () {
-	        return "new Decimal128(\"" + this.toString() + "\")";
+	        return "new Decimal128(\"".concat(this.toString(), "\")");
 	    };
 	    return Decimal128;
 	}());
@@ -4405,7 +4477,7 @@ var BSON = (function (exports) {
 	        // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user
 	        // explicitly provided `-0` then we need to ensure the sign makes it into the output
 	        if (Object.is(Math.sign(this.value), -0)) {
-	            return { $numberDouble: "-" + this.value.toFixed(1) };
+	            return { $numberDouble: "-".concat(this.value.toFixed(1)) };
 	        }
 	        var $numberDouble;
 	        if (Number.isInteger(this.value)) {
@@ -4430,7 +4502,7 @@ var BSON = (function (exports) {
 	    };
 	    Double.prototype.inspect = function () {
 	        var eJSON = this.toExtendedJSON();
-	        return "new Double(" + eJSON.$numberDouble + ")";
+	        return "new Double(".concat(eJSON.$numberDouble, ")");
 	    };
 	    return Double;
 	}());
@@ -4484,7 +4556,7 @@ var BSON = (function (exports) {
 	        return this.inspect();
 	    };
 	    Int32.prototype.inspect = function () {
-	        return "new Int32(" + this.valueOf() + ")";
+	        return "new Int32(".concat(this.valueOf(), ")");
 	    };
 	    return Int32;
 	}());
@@ -4590,7 +4662,8 @@ var BSON = (function (exports) {
 	            this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
 	        }
 	        else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
-	            this[kId] = ensureBuffer(workingId);
+	            // If intstanceof matches we can escape calling ensure buffer in Node.js environments
+	            this[kId] = workingId instanceof buffer_1 ? workingId : ensureBuffer(workingId);
 	        }
 	        else if (typeof workingId === 'string') {
 	            if (workingId.length === 12) {
@@ -4817,7 +4890,7 @@ var BSON = (function (exports) {
 	        return this.inspect();
 	    };
 	    ObjectId.prototype.inspect = function () {
-	        return "new ObjectId(\"" + this.toHexString() + "\")";
+	        return "new ObjectId(\"".concat(this.toHexString(), "\")");
 	    };
 	    /** @internal */
 	    ObjectId.index = Math.floor(Math.random() * 0xffffff);
@@ -4857,10 +4930,10 @@ var BSON = (function (exports) {
 	        this.pattern = pattern;
 	        this.options = alphabetize(options !== null && options !== void 0 ? options : '');
 	        if (this.pattern.indexOf('\x00') !== -1) {
-	            throw new BSONError("BSON Regex patterns cannot contain null bytes, found: " + JSON.stringify(this.pattern));
+	            throw new BSONError("BSON Regex patterns cannot contain null bytes, found: ".concat(JSON.stringify(this.pattern)));
 	        }
 	        if (this.options.indexOf('\x00') !== -1) {
-	            throw new BSONError("BSON Regex options cannot contain null bytes, found: " + JSON.stringify(this.options));
+	            throw new BSONError("BSON Regex options cannot contain null bytes, found: ".concat(JSON.stringify(this.options)));
 	        }
 	        // Validate options
 	        for (var i = 0; i < this.options.length; i++) {
@@ -4870,7 +4943,7 @@ var BSON = (function (exports) {
 	                this.options[i] === 'l' ||
 	                this.options[i] === 's' ||
 	                this.options[i] === 'u')) {
-	                throw new BSONError("The regular expression option [" + this.options[i] + "] is not supported");
+	                throw new BSONError("The regular expression option [".concat(this.options[i], "] is not supported"));
 	            }
 	        }
 	    }
@@ -4901,7 +4974,7 @@ var BSON = (function (exports) {
 	        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 BSONTypeError("Unexpected BSONRegExp EJSON object form: ".concat(JSON.stringify(doc)));
 	    };
 	    return BSONRegExp;
 	}());
@@ -4930,7 +5003,7 @@ var BSON = (function (exports) {
 	    };
 	    /** @internal */
 	    BSONSymbol.prototype.inspect = function () {
-	        return "new BSONSymbol(\"" + this.value + "\")";
+	        return "new BSONSymbol(\"".concat(this.value, "\")");
 	    };
 	    BSONSymbol.prototype.toJSON = function () {
 	        return this.value;
@@ -4962,7 +5035,7 @@ var BSON = (function (exports) {
 	    function Timestamp(low, high) {
 	        var _this = this;
 	        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-	        ///@ts-expect-error
+	        // @ts-expect-error
 	        if (!(_this instanceof Timestamp))
 	            return new Timestamp(low, high);
 	        if (Long.isLong(low)) {
@@ -5026,7 +5099,7 @@ var BSON = (function (exports) {
 	        return this.inspect();
 	    };
 	    Timestamp.prototype.inspect = function () {
-	        return "new Timestamp({ t: " + this.getHighBits() + ", i: " + this.getLowBits() + " })";
+	        return "new Timestamp({ t: ".concat(this.getHighBits(), ", i: ").concat(this.getLowBits(), " })");
 	    };
 	    Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 	    return Timestamp;
@@ -5036,11 +5109,12 @@ var BSON = (function (exports) {
 	    return (isObjectLike(value) && Reflect.has(value, '_bsontype') && typeof value._bsontype === 'string');
 	}
 	// INT32 boundaries
-	var BSON_INT32_MAX$1 = 0x7fffffff;
-	var BSON_INT32_MIN$1 = -0x80000000;
+	var BSON_INT32_MAX = 0x7fffffff;
+	var BSON_INT32_MIN = -0x80000000;
 	// INT64 boundaries
-	var BSON_INT64_MAX$1 = 0x7fffffffffffffff;
-	var BSON_INT64_MIN$1 = -0x8000000000000000;
+	// const BSON_INT64_MAX = 0x7fffffffffffffff; // TODO(NODE-4377): This number cannot be precisely represented in JS
+	var BSON_INT64_MAX = 0x8000000000000000;
+	var BSON_INT64_MIN = -0x8000000000000000;
 	// all the types where we don't need to do any special processing and can just pass the EJSON
 	//straight to type.fromExtendedJSON
 	var keysToCodecs = {
@@ -5068,9 +5142,9 @@ var BSON = (function (exports) {
 	        // if it's an integer, should interpret as smallest BSON integer
 	        // that can represent it exactly. (if out of range, interpret as double.)
 	        if (Math.floor(value) === value) {
-	            if (value >= BSON_INT32_MIN$1 && value <= BSON_INT32_MAX$1)
+	            if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX)
 	                return new Int32(value);
-	            if (value >= BSON_INT64_MIN$1 && value <= BSON_INT64_MAX$1)
+	            if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX)
 	                return Long.fromNumber(value);
 	        }
 	        // If the number is a non-integer or out of integer range, should interpret as BSON Double.
@@ -5135,7 +5209,7 @@ var BSON = (function (exports) {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	function serializeArray(array, options) {
 	    return array.map(function (v, index) {
-	        options.seenObjects.push({ propertyName: "index " + index, obj: null });
+	        options.seenObjects.push({ propertyName: "index ".concat(index), obj: null });
 	        try {
 	            return serializeValue(v, options);
 	        }
@@ -5157,20 +5231,20 @@ var BSON = (function (exports) {
 	            var props = options.seenObjects.map(function (entry) { return entry.propertyName; });
 	            var leadingPart = props
 	                .slice(0, index)
-	                .map(function (prop) { return prop + " -> "; })
+	                .map(function (prop) { return "".concat(prop, " -> "); })
 	                .join('');
 	            var alreadySeen = props[index];
 	            var circularPart = ' -> ' +
 	                props
 	                    .slice(index + 1, props.length - 1)
-	                    .map(function (prop) { return prop + " -> "; })
+	                    .map(function (prop) { return "".concat(prop, " -> "); })
 	                    .join('');
 	            var current = props[props.length - 1];
 	            var leadingSpace = ' '.repeat(leadingPart.length + alreadySeen.length / 2);
 	            var dashes = '-'.repeat(circularPart.length + (alreadySeen.length + current.length) / 2 - 1);
 	            throw new BSONTypeError('Converting circular structure to EJSON:\n' +
-	                ("    " + leadingPart + alreadySeen + circularPart + current + "\n") +
-	                ("    " + leadingSpace + "\\" + dashes + "/"));
+	                "    ".concat(leadingPart).concat(alreadySeen).concat(circularPart).concat(current, "\n") +
+	                "    ".concat(leadingSpace, "\\").concat(dashes, "/"));
 	        }
 	        options.seenObjects[options.seenObjects.length - 1].obj = value;
 	    }
@@ -5194,7 +5268,7 @@ var BSON = (function (exports) {
 	    if (typeof value === 'number' && (!options.relaxed || !isFinite(value))) {
 	        // it's an integer
 	        if (Math.floor(value) === value) {
-	            var int32Range = value >= BSON_INT32_MIN$1 && value <= BSON_INT32_MAX$1, int64Range = value >= BSON_INT64_MIN$1 && value <= BSON_INT64_MAX$1;
+	            var int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX, int64Range = value >= BSON_INT64_MIN && value <= BSON_INT64_MAX;
 	            // interpret as being of the smallest BSON integer type that can represent the number exactly
 	            if (int32Range)
 	                return { $numberInt: value.toString() };
@@ -5249,7 +5323,18 @@ var BSON = (function (exports) {
 	        for (var name in doc) {
 	            options.seenObjects.push({ propertyName: name, obj: null });
 	            try {
-	                _doc[name] = serializeValue(doc[name], options);
+	                var value = serializeValue(doc[name], options);
+	                if (name === '__proto__') {
+	                    Object.defineProperty(_doc, name, {
+	                        value: value,
+	                        writable: true,
+	                        enumerable: true,
+	                        configurable: true
+	                    });
+	                }
+	                else {
+	                    _doc[name] = value;
+	                }
 	            }
 	            finally {
 	                options.seenObjects.pop();
@@ -5319,7 +5404,7 @@ var BSON = (function (exports) {
 	            finalOptions.relaxed = !finalOptions.strict;
 	        return JSON.parse(text, function (key, value) {
 	            if (key.indexOf('\x00') !== -1) {
-	                throw new BSONError("BSON Document field names cannot contain null bytes, found: " + JSON.stringify(key));
+	                throw new BSONError("BSON Document field names cannot contain null bytes, found: ".concat(JSON.stringify(key)));
 	            }
 	            return deserializeValue(value, finalOptions);
 	        });
@@ -5508,85 +5593,6 @@ var BSON = (function (exports) {
 	    }());
 	}
 
-	/** @internal */
-	var BSON_INT32_MAX = 0x7fffffff;
-	/** @internal */
-	var BSON_INT32_MIN = -0x80000000;
-	/** @internal */
-	var BSON_INT64_MAX = Math.pow(2, 63) - 1;
-	/** @internal */
-	var BSON_INT64_MIN = -Math.pow(2, 63);
-	/**
-	 * Any integer up to 2^53 can be precisely represented by a double.
-	 * @internal
-	 */
-	var JS_INT_MAX = Math.pow(2, 53);
-	/**
-	 * Any integer down to -2^53 can be precisely represented by a double.
-	 * @internal
-	 */
-	var JS_INT_MIN = -Math.pow(2, 53);
-	/** Number BSON Type @internal */
-	var BSON_DATA_NUMBER = 1;
-	/** String BSON Type @internal */
-	var BSON_DATA_STRING = 2;
-	/** Object BSON Type @internal */
-	var BSON_DATA_OBJECT = 3;
-	/** Array BSON Type @internal */
-	var BSON_DATA_ARRAY = 4;
-	/** Binary BSON Type @internal */
-	var BSON_DATA_BINARY = 5;
-	/** Binary BSON Type @internal */
-	var BSON_DATA_UNDEFINED = 6;
-	/** ObjectId BSON Type @internal */
-	var BSON_DATA_OID = 7;
-	/** Boolean BSON Type @internal */
-	var BSON_DATA_BOOLEAN = 8;
-	/** Date BSON Type @internal */
-	var BSON_DATA_DATE = 9;
-	/** null BSON Type @internal */
-	var BSON_DATA_NULL = 10;
-	/** RegExp BSON Type @internal */
-	var BSON_DATA_REGEXP = 11;
-	/** Code BSON Type @internal */
-	var BSON_DATA_DBPOINTER = 12;
-	/** Code BSON Type @internal */
-	var BSON_DATA_CODE = 13;
-	/** Symbol BSON Type @internal */
-	var BSON_DATA_SYMBOL = 14;
-	/** Code with Scope BSON Type @internal */
-	var BSON_DATA_CODE_W_SCOPE = 15;
-	/** 32 bit Integer BSON Type @internal */
-	var BSON_DATA_INT = 16;
-	/** Timestamp BSON Type @internal */
-	var BSON_DATA_TIMESTAMP = 17;
-	/** Long BSON Type @internal */
-	var BSON_DATA_LONG = 18;
-	/** Decimal128 BSON Type @internal */
-	var BSON_DATA_DECIMAL128 = 19;
-	/** MinKey BSON Type @internal */
-	var BSON_DATA_MIN_KEY = 0xff;
-	/** MaxKey BSON Type @internal */
-	var BSON_DATA_MAX_KEY = 0x7f;
-	/** Binary Default Type @internal */
-	var BSON_BINARY_SUBTYPE_DEFAULT = 0;
-	/** Binary Function Type @internal */
-	var BSON_BINARY_SUBTYPE_FUNCTION = 1;
-	/** Binary Byte Array Type @internal */
-	var BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
-	/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */
-	var BSON_BINARY_SUBTYPE_UUID = 3;
-	/** Binary UUID Type @internal */
-	var BSON_BINARY_SUBTYPE_UUID_NEW = 4;
-	/** Binary MD5 Type @internal */
-	var BSON_BINARY_SUBTYPE_MD5 = 5;
-	/** Encrypted BSON type @internal */
-	var BSON_BINARY_SUBTYPE_ENCRYPTED = 6;
-	/** Column BSON type @internal */
-	var BSON_BINARY_SUBTYPE_COLUMN = 7;
-	/** Binary User Defined Type @internal */
-	var BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
-
 	function calculateObjectSize$1(object, serializeFunctions, ignoreUndefined) {
 	    var totalLength = 4 + 1;
 	    if (Array.isArray(object)) {
@@ -5624,7 +5630,7 @@ var BSON = (function (exports) {
 	            if (Math.floor(value) === value &&
 	                value >= JS_INT_MIN &&
 	                value <= JS_INT_MAX) {
-	                if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
+	                if (value >= BSON_INT32_MIN$1 && value <= BSON_INT32_MAX$1) {
 	                    // 32 bit
 	                    return (name != null ? buffer_1.byteLength(name, 'utf8') + 1 : 0) + (4 + 1);
 	                }
@@ -5685,13 +5691,14 @@ var BSON = (function (exports) {
 	                }
 	            }
 	            else if (value['_bsontype'] === 'Binary') {
+	                var binary = value;
 	                // Check what kind of subtype we have
-	                if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
+	                if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
 	                    return ((name != null ? buffer_1.byteLength(name, 'utf8') + 1 : 0) +
-	                        (value.position + 1 + 4 + 1 + 4));
+	                        (binary.position + 1 + 4 + 1 + 4));
 	                }
 	                else {
-	                    return ((name != null ? buffer_1.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1));
+	                    return ((name != null ? buffer_1.byteLength(name, 'utf8') + 1 : 0) + (binary.position + 1 + 4 + 1));
 	                }
 	            }
 	            else if (value['_bsontype'] === 'Symbol') {
@@ -5828,16 +5835,16 @@ var BSON = (function (exports) {
 	        (buffer[index + 2] << 16) |
 	        (buffer[index + 3] << 24);
 	    if (size < 5) {
-	        throw new BSONError("bson size must be >= 5, is " + size);
+	        throw new BSONError("bson size must be >= 5, is ".concat(size));
 	    }
 	    if (options.allowObjectSmallerThanBufferSize && buffer.length < size) {
-	        throw new BSONError("buffer length " + buffer.length + " must be >= bson size " + size);
+	        throw new BSONError("buffer length ".concat(buffer.length, " must be >= bson size ").concat(size));
 	    }
 	    if (!options.allowObjectSmallerThanBufferSize && buffer.length !== size) {
-	        throw new BSONError("buffer length " + buffer.length + " must === bson size " + size);
+	        throw new BSONError("buffer length ".concat(buffer.length, " must === bson size ").concat(size));
 	    }
 	    if (size + index > buffer.byteLength) {
-	        throw new BSONError("(bson size " + size + " + options.index " + index + " must be <= buffer length " + buffer.byteLength + ")");
+	        throw new BSONError("(bson size ".concat(size, " + options.index ").concat(index, " must be <= buffer length ").concat(buffer.byteLength, ")"));
 	    }
 	    // Illegal end value
 	    if (buffer[index + size - 1] !== 0) {
@@ -5914,6 +5921,7 @@ var BSON = (function (exports) {
 	    var done = false;
 	    var isPossibleDBRef = isArray ? false : null;
 	    // While we have more left data left keep parsing
+	    var dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 	    while (!done) {
 	        // Read the type
 	        var elementType = buffer[index++];
@@ -5974,11 +5982,11 @@ var BSON = (function (exports) {
 	                    (buffer[index++] << 24);
 	        }
 	        else if (elementType === BSON_DATA_NUMBER && promoteValues === false) {
-	            value = new Double(buffer.readDoubleLE(index));
+	            value = new Double(dataview.getFloat64(index, true));
 	            index = index + 8;
 	        }
 	        else if (elementType === BSON_DATA_NUMBER) {
-	            value = buffer.readDoubleLE(index);
+	            value = dataview.getFloat64(index, true);
 	            index = index + 8;
 	        }
 	        else if (elementType === BSON_DATA_DATE) {
@@ -6124,6 +6132,9 @@ var BSON = (function (exports) {
 	                }
 	                else {
 	                    value = new Binary(buffer.slice(index, index + binarySize), subType);
+	                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
+	                        value = value.toUUID();
+	                    }
 	                }
 	            }
 	            else {
@@ -6149,8 +6160,11 @@ var BSON = (function (exports) {
 	                if (promoteBuffers && promoteValues) {
 	                    value = _buffer;
 	                }
+	                else if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
+	                    value = new Binary(buffer.slice(index, index + binarySize), subType).toUUID();
+	                }
 	                else {
-	                    value = new Binary(_buffer, subType);
+	                    value = new Binary(buffer.slice(index, index + binarySize), subType);
 	                }
 	            }
 	            // Update the index
@@ -6376,7 +6390,7 @@ var BSON = (function (exports) {
 	            value = new DBRef(namespace, oid);
 	        }
 	        else {
-	            throw new BSONError('Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname "' + name + '"');
+	            throw new BSONError("Detected unknown BSON type ".concat(elementType.toString(16), " for fieldname \"").concat(name, "\""));
 	        }
 	        if (name === '__proto__') {
 	            Object.defineProperty(object, name, {
@@ -6414,10 +6428,12 @@ var BSON = (function (exports) {
 	 * @internal
 	 */
 	function isolateEval(functionString, functionCache, object) {
+	    // eslint-disable-next-line @typescript-eslint/no-implied-eval
 	    if (!functionCache)
 	        return new Function(functionString);
 	    // Check for cache hit, eval if missing and return cached function
 	    if (functionCache[functionString] == null) {
+	        // eslint-disable-next-line @typescript-eslint/no-implied-eval
 	        functionCache[functionString] = new Function(functionString);
 	    }
 	    // Set the object
@@ -6439,74 +6455,6 @@ var BSON = (function (exports) {
 	    return value;
 	}
 
-	// Copyright (c) 2008, Fair Oaks Labs, Inc.
-	function writeIEEE754(buffer, value, offset, endian, mLen, nBytes) {
-	    var e;
-	    var m;
-	    var c;
-	    var bBE = endian === 'big';
-	    var eLen = nBytes * 8 - mLen - 1;
-	    var eMax = (1 << eLen) - 1;
-	    var eBias = eMax >> 1;
-	    var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-	    var i = bBE ? nBytes - 1 : 0;
-	    var d = bBE ? -1 : 1;
-	    var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
-	    value = Math.abs(value);
-	    if (isNaN(value) || value === Infinity) {
-	        m = isNaN(value) ? 1 : 0;
-	        e = eMax;
-	    }
-	    else {
-	        e = Math.floor(Math.log(value) / Math.LN2);
-	        if (value * (c = Math.pow(2, -e)) < 1) {
-	            e--;
-	            c *= 2;
-	        }
-	        if (e + eBias >= 1) {
-	            value += rt / c;
-	        }
-	        else {
-	            value += rt * Math.pow(2, 1 - eBias);
-	        }
-	        if (value * c >= 2) {
-	            e++;
-	            c /= 2;
-	        }
-	        if (e + eBias >= eMax) {
-	            m = 0;
-	            e = eMax;
-	        }
-	        else if (e + eBias >= 1) {
-	            m = (value * c - 1) * Math.pow(2, mLen);
-	            e = e + eBias;
-	        }
-	        else {
-	            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
-	            e = 0;
-	        }
-	    }
-	    if (isNaN(value))
-	        m = 0;
-	    while (mLen >= 8) {
-	        buffer[offset + i] = m & 0xff;
-	        i += d;
-	        m /= 256;
-	        mLen -= 8;
-	    }
-	    e = (e << mLen) | m;
-	    if (isNaN(value))
-	        e += 8;
-	    eLen += mLen;
-	    while (eLen > 0) {
-	        buffer[offset + i] = e & 0xff;
-	        i += d;
-	        e /= 256;
-	        eLen -= 8;
-	    }
-	    buffer[offset + i - d] |= s * 128;
-	}
-
 	var regexp = /\x00/; // eslint-disable-line no-control-regex
 	var ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);
 	/*
@@ -6537,12 +6485,14 @@ var BSON = (function (exports) {
 	    buffer[index++] = 0;
 	    return index;
 	}
+	var SPACE_FOR_FLOAT64 = new Uint8Array(8);
+	var DV_FOR_FLOAT64 = new DataView(SPACE_FOR_FLOAT64.buffer, SPACE_FOR_FLOAT64.byteOffset, SPACE_FOR_FLOAT64.byteLength);
 	function serializeNumber(buffer, key, value, index, isArray) {
 	    // We have an integer value
 	    // TODO(NODE-2529): Add support for big int
 	    if (Number.isInteger(value) &&
-	        value >= BSON_INT32_MIN &&
-	        value <= BSON_INT32_MAX) {
+	        value >= BSON_INT32_MIN$1 &&
+	        value <= BSON_INT32_MAX$1) {
 	        // If the value fits in 32 bits encode as int32
 	        // Set int type 32 bits or less
 	        buffer[index++] = BSON_DATA_INT;
@@ -6570,7 +6520,8 @@ var BSON = (function (exports) {
 	        index = index + numberOfWrittenBytes;
 	        buffer[index++] = 0;
 	        // Write float
-	        writeIEEE754(buffer, value, index, 'little', 52, 8);
+	        DV_FOR_FLOAT64.setFloat64(0, value, true);
+	        buffer.set(SPACE_FOR_FLOAT64, index);
 	        // Adjust index
 	        index = index + 8;
 	    }
@@ -6849,7 +6800,8 @@ var BSON = (function (exports) {
 	    index = index + numberOfWrittenBytes;
 	    buffer[index++] = 0;
 	    // Write float
-	    writeIEEE754(buffer, value.value, index, 'little', 52, 8);
+	    DV_FOR_FLOAT64.setFloat64(0, value.value, true);
+	    buffer.set(SPACE_FOR_FLOAT64, index);
 	    // Adjust index
 	    index = index + 8;
 	    return index;
@@ -7059,7 +7011,7 @@ var BSON = (function (exports) {
 	    if (Array.isArray(object)) {
 	        // Get object keys
 	        for (var i = 0; i < object.length; i++) {
-	            var key = '' + i;
+	            var key = "".concat(i);
 	            var value = object[i];
 	            // Is there an override value
 	            if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
@@ -7134,7 +7086,7 @@ var BSON = (function (exports) {
 	                index = serializeMinMax(buffer, key, value, index, true);
 	            }
 	            else if (typeof value['_bsontype'] !== 'undefined') {
-	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+	                throw new BSONTypeError("Unrecognized or invalid _bsontype: ".concat(String(value['_bsontype'])));
 	            }
 	        }
 	    }
@@ -7233,7 +7185,7 @@ var BSON = (function (exports) {
 	                index = serializeMinMax(buffer, key, value, index);
 	            }
 	            else if (typeof value['_bsontype'] !== 'undefined') {
-	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+	                throw new BSONTypeError("Unrecognized or invalid _bsontype: ".concat(String(value['_bsontype'])));
 	            }
 	        }
 	    }
@@ -7338,7 +7290,7 @@ var BSON = (function (exports) {
 	                index = serializeMinMax(buffer, key, value, index);
 	            }
 	            else if (typeof value['_bsontype'] !== 'undefined') {
-	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+	                throw new BSONTypeError("Unrecognized or invalid _bsontype: ".concat(String(value['_bsontype'])));
 	            }
 	        }
 	    }
@@ -7550,10 +7502,10 @@ var BSON = (function (exports) {
 	exports.BSON_DATA_SYMBOL = BSON_DATA_SYMBOL;
 	exports.BSON_DATA_TIMESTAMP = BSON_DATA_TIMESTAMP;
 	exports.BSON_DATA_UNDEFINED = BSON_DATA_UNDEFINED;
-	exports.BSON_INT32_MAX = BSON_INT32_MAX;
-	exports.BSON_INT32_MIN = BSON_INT32_MIN;
-	exports.BSON_INT64_MAX = BSON_INT64_MAX;
-	exports.BSON_INT64_MIN = BSON_INT64_MIN;
+	exports.BSON_INT32_MAX = BSON_INT32_MAX$1;
+	exports.BSON_INT32_MIN = BSON_INT32_MIN$1;
+	exports.BSON_INT64_MAX = BSON_INT64_MAX$1;
+	exports.BSON_INT64_MIN = BSON_INT64_MIN$1;
 	exports.Binary = Binary;
 	exports.Code = Code;
 	exports.DBRef = DBRef;