bson 4.6.2 → 4.6.5

package/dist/bson.esm.js

@@ -97,11 +97,11 @@ function checkForMath(potentialGlobal) {
 }
 // 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')());
 }
 
@@ -127,27 +127,17 @@ var insecureRandomBytes = function insecureRandomBytes(size) {
     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.alloc(size)); };
+    {
+        var requiredRandomBytes = void 0;
+        try {
+            requiredRandomBytes = require('crypto').randomBytes;
         }
+        catch (e) {
+            // keep the fallback
+        }
+        // NOTE: in transpiled cases the above require might return null/undefined
+        return requiredRandomBytes || 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.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) {
@@ -404,7 +394,7 @@ var UUID = /** @class */ (function () {
         return this.inspect();
     };
     UUID.prototype.inspect = function () {
-        return "new UUID(\"" + this.toHexString() + "\")";
+        return "new UUID(\"".concat(this.toHexString(), "\")");
     };
     return UUID;
 }());
@@ -413,9 +403,17 @@ Object.defineProperty(UUID.prototype, '_bsontype', { value: 'UUID' });
 /**
  * A class representation of the BSON Binary type.
  * @public
+ * @category BSONType
  */
 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.
      */
@@ -575,7 +573,7 @@ var Binary = /** @class */ (function () {
         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) {
@@ -599,7 +597,7 @@ var Binary = /** @class */ (function () {
             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);
     };
@@ -609,7 +607,7 @@ var Binary = /** @class */ (function () {
     };
     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
@@ -643,6 +641,7 @@ Object.defineProperty(Binary.prototype, '_bsontype', { value: 'Binary' });
 /**
  * A class representation of the BSON Code type.
  * @public
+ * @category BSONType
  */
 var Code = /** @class */ (function () {
     /**
@@ -675,7 +674,7 @@ var Code = /** @class */ (function () {
     };
     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;
 }());
@@ -691,6 +690,7 @@ function isDBRefLike(value) {
 /**
  * A class representation of the BSON DBRef type.
  * @public
+ * @category BSONType
  */
 var DBRef = /** @class */ (function () {
     /**
@@ -765,7 +765,7 @@ var DBRef = /** @class */ (function () {
     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;
 }());
@@ -795,6 +795,7 @@ var UINT_CACHE = {};
 /**
  * A class representing a 64-bit integer
  * @public
+ * @category BSONType
  * @remarks
  * The internal representation of a long is the two given signed, 32-bit values.
  * We use 32-bit pieces because these are the size of integers on which
@@ -1001,7 +1002,6 @@ var Long = /** @class */ (function () {
     /**
      * 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;
     };
@@ -1158,6 +1158,7 @@ var Long = /** @class */ (function () {
         // 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
@@ -1641,7 +1642,7 @@ var Long = /** @class */ (function () {
         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. */
@@ -1752,11 +1753,12 @@ function lessThan(left, right) {
     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.
  * @public
+ * @category BSONType
  */
 var Decimal128 = /** @class */ (function () {
     /**
@@ -2249,35 +2251,35 @@ var Decimal128 = /** @class */ (function () {
             // 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 {
@@ -2285,7 +2287,7 @@ var Decimal128 = /** @class */ (function () {
                 // 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 {
@@ -2297,7 +2299,7 @@ var Decimal128 = /** @class */ (function () {
                     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++]));
                 }
             }
         }
@@ -2319,7 +2321,7 @@ var Decimal128 = /** @class */ (function () {
         return this.inspect();
     };
     Decimal128.prototype.inspect = function () {
-        return "new Decimal128(\"" + this.toString() + "\")";
+        return "new Decimal128(\"".concat(this.toString(), "\")");
     };
     return Decimal128;
 }());
@@ -2328,6 +2330,7 @@ Object.defineProperty(Decimal128.prototype, '_bsontype', { value: 'Decimal128' }
 /**
  * A class representation of the BSON Double type.
  * @public
+ * @category BSONType
  */
 var Double = /** @class */ (function () {
     /**
@@ -2365,7 +2368,7 @@ var Double = /** @class */ (function () {
         // 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)) {
@@ -2390,7 +2393,7 @@ var Double = /** @class */ (function () {
     };
     Double.prototype.inspect = function () {
         var eJSON = this.toExtendedJSON();
-        return "new Double(" + eJSON.$numberDouble + ")";
+        return "new Double(".concat(eJSON.$numberDouble, ")");
     };
     return Double;
 }());
@@ -2399,6 +2402,7 @@ Object.defineProperty(Double.prototype, '_bsontype', { value: 'Double' });
 /**
  * A class representation of a BSON Int32 type.
  * @public
+ * @category BSONType
  */
 var Int32 = /** @class */ (function () {
     /**
@@ -2443,7 +2447,7 @@ var Int32 = /** @class */ (function () {
         return this.inspect();
     };
     Int32.prototype.inspect = function () {
-        return "new Int32(" + this.valueOf() + ")";
+        return "new Int32(".concat(this.valueOf(), ")");
     };
     return Int32;
 }());
@@ -2452,6 +2456,7 @@ Object.defineProperty(Int32.prototype, '_bsontype', { value: 'Int32' });
 /**
  * A class representation of the BSON MaxKey type.
  * @public
+ * @category BSONType
  */
 var MaxKey = /** @class */ (function () {
     function MaxKey() {
@@ -2480,6 +2485,7 @@ Object.defineProperty(MaxKey.prototype, '_bsontype', { value: 'MaxKey' });
 /**
  * A class representation of the BSON MinKey type.
  * @public
+ * @category BSONType
  */
 var MinKey = /** @class */ (function () {
     function MinKey() {
@@ -2513,6 +2519,7 @@ var kId = Symbol('id');
 /**
  * A class representation of the BSON ObjectId type.
  * @public
+ * @category BSONType
  */
 var ObjectId = /** @class */ (function () {
     /**
@@ -2546,7 +2553,8 @@ var ObjectId = /** @class */ (function () {
             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 ? workingId : ensureBuffer(workingId);
         }
         else if (typeof workingId === 'string') {
             if (workingId.length === 12) {
@@ -2773,7 +2781,7 @@ var ObjectId = /** @class */ (function () {
         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);
@@ -2800,6 +2808,7 @@ function alphabetize(str) {
 /**
  * A class representation of the BSON RegExp type.
  * @public
+ * @category BSONType
  */
 var BSONRegExp = /** @class */ (function () {
     /**
@@ -2812,10 +2821,10 @@ var BSONRegExp = /** @class */ (function () {
         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++) {
@@ -2825,7 +2834,7 @@ var BSONRegExp = /** @class */ (function () {
                 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"));
             }
         }
     }
@@ -2856,7 +2865,7 @@ var BSONRegExp = /** @class */ (function () {
         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;
 }());
@@ -2865,6 +2874,7 @@ Object.defineProperty(BSONRegExp.prototype, '_bsontype', { value: 'BSONRegExp' }
 /**
  * A class representation of the BSON Symbol type.
  * @public
+ * @category BSONType
  */
 var BSONSymbol = /** @class */ (function () {
     /**
@@ -2884,7 +2894,7 @@ var BSONSymbol = /** @class */ (function () {
     };
     /** @internal */
     BSONSymbol.prototype.inspect = function () {
-        return "new BSONSymbol(\"" + this.value + "\")";
+        return "new BSONSymbol(\"".concat(this.value, "\")");
     };
     BSONSymbol.prototype.toJSON = function () {
         return this.value;
@@ -2907,13 +2917,16 @@ Object.defineProperty(BSONSymbol.prototype, '_bsontype', { value: 'Symbol' });
 
 /** @public */
 var LongWithoutOverridesClass = Long;
-/** @public */
+/**
+ * @public
+ * @category BSONType
+ * */
 var Timestamp = /** @class */ (function (_super) {
     __extends(Timestamp, _super);
     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)) {
@@ -2977,7 +2990,7 @@ var Timestamp = /** @class */ (function (_super) {
         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;
@@ -2990,7 +3003,8 @@ function isBSONType(value) {
 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
@@ -3086,7 +3100,7 @@ function deserializeValue(value, options) {
 // 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);
         }
@@ -3108,20 +3122,20 @@ function serializeValue(value, options) {
             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;
     }
@@ -3200,7 +3214,18 @@ function serializeDocument(doc, options) {
         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();
@@ -3270,7 +3295,7 @@ var EJSON;
             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);
         });
@@ -3636,13 +3661,14 @@ value, serializeFunctions, isArray, ignoreUndefined) {
                 }
             }
             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.byteLength(name, 'utf8') + 1 : 0) +
-                        (value.position + 1 + 4 + 1 + 4));
+                        (binary.position + 1 + 4 + 1 + 4));
                 }
                 else {
-                    return ((name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1));
+                    return ((name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (binary.position + 1 + 4 + 1));
                 }
             }
             else if (value['_bsontype'] === 'Symbol') {
@@ -3779,16 +3805,16 @@ function deserialize$1(buffer, options, isArray) {
         (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) {
@@ -3865,6 +3891,7 @@ function deserializeObject(buffer, index, options, isArray) {
     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++];
@@ -3925,11 +3952,11 @@ function deserializeObject(buffer, index, options, isArray) {
                     (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) {
@@ -4327,7 +4354,7 @@ function deserializeObject(buffer, index, options, isArray) {
             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, {
@@ -4365,10 +4392,12 @@ function deserializeObject(buffer, index, options, isArray) {
  * @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
@@ -4390,74 +4419,6 @@ function getValidatedString(buffer, start, end, shouldValidateUtf8) {
     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']);
 /*
@@ -4488,6 +4449,8 @@ function serializeString(buffer, key, value, index, isArray) {
     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
@@ -4521,7 +4484,8 @@ function serializeNumber(buffer, key, value, index, isArray) {
         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;
     }
@@ -4800,7 +4764,8 @@ function serializeDouble(buffer, key, value, index, isArray) {
     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;
@@ -5010,7 +4975,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
     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') {
@@ -5085,7 +5050,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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'])));
             }
         }
     }
@@ -5184,7 +5149,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: ' + value['_bsontype']);
+                throw new BSONTypeError("Unrecognized or invalid _bsontype: ".concat(String(value['_bsontype'])));
             }
         }
     }
@@ -5289,7 +5254,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: ' + value['_bsontype']);
+                throw new BSONTypeError("Unrecognized or invalid _bsontype: ".concat(String(value['_bsontype'])));
             }
         }
     }