bson 4.6.4 → 4.6.5

package/dist/bson.browser.umd.js

@@ -2134,11 +2134,11 @@
 	}
 	// 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')());
 	}
 
@@ -2164,27 +2164,20 @@
 	    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) {
@@ -2441,7 +2434,7 @@
 	        return this.inspect();
 	    };
 	    UUID.prototype.inspect = function () {
-	        return "new UUID(\"" + this.toHexString() + "\")";
+	        return "new UUID(\"".concat(this.toHexString(), "\")");
 	    };
 	    return UUID;
 	}());
@@ -2454,6 +2447,13 @@
 	 */
 	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.
 	     */
@@ -2613,7 +2613,7 @@
 	        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) {
@@ -2637,7 +2637,7 @@
 	            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);
 	    };
@@ -2647,7 +2647,7 @@
 	    };
 	    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
@@ -2714,7 +2714,7 @@
 	    };
 	    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;
 	}());
@@ -2805,7 +2805,7 @@
 	    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;
 	}());
@@ -3042,7 +3042,6 @@
 	    /**
 	     * 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;
 	    };
@@ -3199,6 +3198,7 @@
 	        // 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
@@ -3682,7 +3682,7 @@
 	        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. */
@@ -3793,7 +3793,7 @@
 	    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.
@@ -4291,35 +4291,35 @@
 	            // 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 {
@@ -4327,7 +4327,7 @@
 	                // 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 {
@@ -4339,7 +4339,7 @@
 	                    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++]));
 	                }
 	            }
 	        }
@@ -4361,7 +4361,7 @@
 	        return this.inspect();
 	    };
 	    Decimal128.prototype.inspect = function () {
-	        return "new Decimal128(\"" + this.toString() + "\")";
+	        return "new Decimal128(\"".concat(this.toString(), "\")");
 	    };
 	    return Decimal128;
 	}());
@@ -4408,7 +4408,7 @@
 	        // 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)) {
@@ -4433,7 +4433,7 @@
 	    };
 	    Double.prototype.inspect = function () {
 	        var eJSON = this.toExtendedJSON();
-	        return "new Double(" + eJSON.$numberDouble + ")";
+	        return "new Double(".concat(eJSON.$numberDouble, ")");
 	    };
 	    return Double;
 	}());
@@ -4487,7 +4487,7 @@
 	        return this.inspect();
 	    };
 	    Int32.prototype.inspect = function () {
-	        return "new Int32(" + this.valueOf() + ")";
+	        return "new Int32(".concat(this.valueOf(), ")");
 	    };
 	    return Int32;
 	}());
@@ -4821,7 +4821,7 @@
 	        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);
@@ -4861,10 +4861,10 @@
 	        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++) {
@@ -4874,7 +4874,7 @@
 	                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"));
 	            }
 	        }
 	    }
@@ -4905,7 +4905,7 @@
 	        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;
 	}());
@@ -4934,7 +4934,7 @@
 	    };
 	    /** @internal */
 	    BSONSymbol.prototype.inspect = function () {
-	        return "new BSONSymbol(\"" + this.value + "\")";
+	        return "new BSONSymbol(\"".concat(this.value, "\")");
 	    };
 	    BSONSymbol.prototype.toJSON = function () {
 	        return this.value;
@@ -4966,7 +4966,7 @@
 	    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)) {
@@ -5030,7 +5030,7 @@
 	        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;
@@ -5043,7 +5043,8 @@
 	var BSON_INT32_MAX$1 = 0x7fffffff;
 	var BSON_INT32_MIN$1 = -0x80000000;
 	// INT64 boundaries
-	var BSON_INT64_MAX$1 = 0x7fffffffffffffff;
+	// const BSON_INT64_MAX = 0x7fffffffffffffff; // TODO(NODE-4377): This number cannot be precisely represented in JS
+	var BSON_INT64_MAX$1 = 0x8000000000000000;
 	var BSON_INT64_MIN$1 = -0x8000000000000000;
 	// all the types where we don't need to do any special processing and can just pass the EJSON
 	//straight to type.fromExtendedJSON
@@ -5139,7 +5140,7 @@
 	// 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);
 	        }
@@ -5161,20 +5162,20 @@
 	            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;
 	    }
@@ -5253,7 +5254,18 @@
 	        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();
@@ -5323,7 +5335,7 @@
 	            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);
 	        });
@@ -5689,13 +5701,14 @@
 	                }
 	            }
 	            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') {
@@ -5832,16 +5845,16 @@
 	        (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) {
@@ -5918,6 +5931,7 @@
 	    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++];
@@ -5978,11 +5992,11 @@
 	                    (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) {
@@ -6380,7 +6394,7 @@
 	            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, {
@@ -6418,10 +6432,12 @@
 	 * @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
@@ -6443,74 +6459,6 @@
 	    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']);
 	/*
@@ -6541,6 +6489,8 @@
 	    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
@@ -6574,7 +6524,8 @@
 	        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;
 	    }
@@ -6853,7 +6804,8 @@
 	    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;
@@ -7063,7 +7015,7 @@
 	    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') {
@@ -7138,7 +7090,7 @@
 	                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'])));
 	            }
 	        }
 	    }
@@ -7237,7 +7189,7 @@
 	                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'])));
 	            }
 	        }
 	    }
@@ -7342,7 +7294,7 @@
 	                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'])));
 	            }
 	        }
 	    }