bson 6.2.0 → 6.4.0

package/lib/bson.mjs

@@ -95,8 +95,8 @@ class BSONError extends Error {
     get name() {
         return 'BSONError';
     }
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
     }
     static isBSONError(value) {
         return (value != null &&
@@ -125,6 +125,94 @@ class BSONRuntimeError extends BSONError {
     }
 }
 
+const FIRST_BIT = 0x80;
+const FIRST_TWO_BITS = 0xc0;
+const FIRST_THREE_BITS = 0xe0;
+const FIRST_FOUR_BITS = 0xf0;
+const FIRST_FIVE_BITS = 0xf8;
+const TWO_BIT_CHAR = 0xc0;
+const THREE_BIT_CHAR = 0xe0;
+const FOUR_BIT_CHAR = 0xf0;
+const CONTINUING_CHAR = 0x80;
+function validateUtf8(bytes, start, end) {
+    let continuation = 0;
+    for (let i = start; i < end; i += 1) {
+        const byte = bytes[i];
+        if (continuation) {
+            if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {
+                return false;
+            }
+            continuation -= 1;
+        }
+        else if (byte & FIRST_BIT) {
+            if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {
+                continuation = 1;
+            }
+            else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {
+                continuation = 2;
+            }
+            else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {
+                continuation = 3;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    return !continuation;
+}
+
+function tryReadBasicLatin(uint8array, start, end) {
+    if (uint8array.length === 0) {
+        return '';
+    }
+    const stringByteLength = end - start;
+    if (stringByteLength === 0) {
+        return '';
+    }
+    if (stringByteLength > 20) {
+        return null;
+    }
+    if (stringByteLength === 1 && uint8array[start] < 128) {
+        return String.fromCharCode(uint8array[start]);
+    }
+    if (stringByteLength === 2 && uint8array[start] < 128 && uint8array[start + 1] < 128) {
+        return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]);
+    }
+    if (stringByteLength === 3 &&
+        uint8array[start] < 128 &&
+        uint8array[start + 1] < 128 &&
+        uint8array[start + 2] < 128) {
+        return (String.fromCharCode(uint8array[start]) +
+            String.fromCharCode(uint8array[start + 1]) +
+            String.fromCharCode(uint8array[start + 2]));
+    }
+    const latinBytes = [];
+    for (let i = start; i < end; i++) {
+        const byte = uint8array[i];
+        if (byte > 127) {
+            return null;
+        }
+        latinBytes.push(byte);
+    }
+    return String.fromCharCode(...latinBytes);
+}
+function tryWriteBasicLatin(destination, source, offset) {
+    if (source.length === 0)
+        return 0;
+    if (source.length > 25)
+        return null;
+    if (destination.length - offset < source.length)
+        return null;
+    for (let charOffset = 0, destinationOffset = offset; charOffset < source.length; charOffset++, destinationOffset++) {
+        const char = source.charCodeAt(charOffset);
+        if (char > 127)
+            return null;
+        destination[destinationOffset] = char;
+    }
+    return source.length;
+}
+
 function nodejsMathRandomBytes(byteLength) {
     return nodeJsByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
 }
@@ -156,6 +244,9 @@ const nodeJsByteUtils = {
     allocate(size) {
         return Buffer.alloc(size);
     },
+    allocateUnsafe(size) {
+        return Buffer.allocUnsafe(size);
+    },
     equals(a, b) {
         return nodeJsByteUtils.toLocalBufferType(a).equals(b);
     },
@@ -180,16 +271,32 @@ const nodeJsByteUtils = {
     toHex(buffer) {
         return nodeJsByteUtils.toLocalBufferType(buffer).toString('hex');
     },
-    fromUTF8(text) {
-        return Buffer.from(text, 'utf8');
-    },
-    toUTF8(buffer, start, end) {
-        return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
+    toUTF8(buffer, start, end, fatal) {
+        const basicLatin = end - start <= 20 ? tryReadBasicLatin(buffer, start, end) : null;
+        if (basicLatin != null) {
+            return basicLatin;
+        }
+        const string = nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
+        if (fatal) {
+            for (let i = 0; i < string.length; i++) {
+                if (string.charCodeAt(i) === 0xfffd) {
+                    if (!validateUtf8(buffer, start, end)) {
+                        throw new BSONError('Invalid UTF-8 string in BSON document');
+                    }
+                    break;
+                }
+            }
+        }
+        return string;
     },
     utf8ByteLength(input) {
         return Buffer.byteLength(input, 'utf8');
     },
     encodeUTF8Into(buffer, source, byteOffset) {
+        const latinBytesWritten = tryWriteBasicLatin(buffer, source, byteOffset);
+        if (latinBytesWritten != null) {
+            return latinBytesWritten;
+        }
         return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');
     },
     randomBytes: nodejsRandomBytes
@@ -245,6 +352,9 @@ const webByteUtils = {
         }
         return new Uint8Array(size);
     },
+    allocateUnsafe(size) {
+        return webByteUtils.allocate(size);
+    },
     equals(a, b) {
         if (a.byteLength !== b.byteLength) {
             return false;
@@ -291,18 +401,27 @@ const webByteUtils = {
     toHex(uint8array) {
         return Array.from(uint8array, byte => byte.toString(16).padStart(2, '0')).join('');
     },
-    fromUTF8(text) {
-        return new TextEncoder().encode(text);
-    },
-    toUTF8(uint8array, start, end) {
-        return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
+    toUTF8(uint8array, start, end, fatal) {
+        const basicLatin = end - start <= 20 ? tryReadBasicLatin(uint8array, start, end) : null;
+        if (basicLatin != null) {
+            return basicLatin;
+        }
+        if (fatal) {
+            try {
+                return new TextDecoder('utf8', { fatal }).decode(uint8array.slice(start, end));
+            }
+            catch (cause) {
+                throw new BSONError('Invalid UTF-8 string in BSON document', { cause });
+            }
+        }
+        return new TextDecoder('utf8', { fatal }).decode(uint8array.slice(start, end));
     },
     utf8ByteLength(input) {
-        return webByteUtils.fromUTF8(input).byteLength;
+        return new TextEncoder().encode(input).byteLength;
     },
-    encodeUTF8Into(buffer, source, byteOffset) {
-        const bytes = webByteUtils.fromUTF8(source);
-        buffer.set(bytes, byteOffset);
+    encodeUTF8Into(uint8array, source, byteOffset) {
+        const bytes = new TextEncoder().encode(source);
+        uint8array.set(bytes, byteOffset);
         return bytes.byteLength;
     },
     randomBytes: webRandomBytes
@@ -310,11 +429,6 @@ const webByteUtils = {
 
 const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuffer !== true;
 const ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
-class BSONDataView extends DataView {
-    static fromUint8Array(input) {
-        return new DataView(input.buffer, input.byteOffset, input.byteLength);
-    }
-}
 
 class BSONValue {
     get [Symbol.for('@@mdb.bson.version')]() {
@@ -416,8 +530,8 @@ class Binary extends BSONValue {
         if (encoding === 'base64')
             return ByteUtils.toBase64(this.buffer);
         if (encoding === 'utf8' || encoding === 'utf-8')
-            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
-        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
+            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength, false);
+        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength, false);
     }
     toExtendedJSON(options) {
         options = options || {};
@@ -1734,7 +1848,7 @@ class Decimal128 extends BSONValue {
         if (isNegative) {
             dec.high = dec.high.or(Long.fromString('9223372036854775808'));
         }
-        const buffer = ByteUtils.allocate(16);
+        const buffer = ByteUtils.allocateUnsafe(16);
         index = 0;
         buffer[index++] = dec.low.low & 0xff;
         buffer[index++] = (dec.low.low >> 8) & 0xff;
@@ -2007,9 +2121,99 @@ class MinKey extends BSONValue {
     }
 }
 
+const FLOAT = new Float64Array(1);
+const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+const NumberUtils = {
+    getInt32LE(source, offset) {
+        return (source[offset] |
+            (source[offset + 1] << 8) |
+            (source[offset + 2] << 16) |
+            (source[offset + 3] << 24));
+    },
+    getUint32LE(source, offset) {
+        return (source[offset] +
+            source[offset + 1] * 256 +
+            source[offset + 2] * 65536 +
+            source[offset + 3] * 16777216);
+    },
+    getUint32BE(source, offset) {
+        return (source[offset + 3] +
+            source[offset + 2] * 256 +
+            source[offset + 1] * 65536 +
+            source[offset] * 16777216);
+    },
+    getBigInt64LE(source, offset) {
+        const lo = NumberUtils.getUint32LE(source, offset);
+        const hi = NumberUtils.getUint32LE(source, offset + 4);
+        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    },
+    getFloat64LE(source, offset) {
+        FLOAT_BYTES[0] = source[offset];
+        FLOAT_BYTES[1] = source[offset + 1];
+        FLOAT_BYTES[2] = source[offset + 2];
+        FLOAT_BYTES[3] = source[offset + 3];
+        FLOAT_BYTES[4] = source[offset + 4];
+        FLOAT_BYTES[5] = source[offset + 5];
+        FLOAT_BYTES[6] = source[offset + 6];
+        FLOAT_BYTES[7] = source[offset + 7];
+        return FLOAT[0];
+    },
+    setInt32BE(destination, offset, value) {
+        destination[offset + 3] = value;
+        value >>>= 8;
+        destination[offset + 2] = value;
+        value >>>= 8;
+        destination[offset + 1] = value;
+        value >>>= 8;
+        destination[offset] = value;
+        return 4;
+    },
+    setInt32LE(destination, offset, value) {
+        destination[offset] = value;
+        value >>>= 8;
+        destination[offset + 1] = value;
+        value >>>= 8;
+        destination[offset + 2] = value;
+        value >>>= 8;
+        destination[offset + 3] = value;
+        return 4;
+    },
+    setBigInt64LE(destination, offset, value) {
+        const mask32bits = BigInt(4294967295);
+        let lo = Number(value & mask32bits);
+        destination[offset] = lo;
+        lo >>= 8;
+        destination[offset + 1] = lo;
+        lo >>= 8;
+        destination[offset + 2] = lo;
+        lo >>= 8;
+        destination[offset + 3] = lo;
+        let hi = Number((value >> BigInt(32)) & mask32bits);
+        destination[offset + 4] = hi;
+        hi >>= 8;
+        destination[offset + 5] = hi;
+        hi >>= 8;
+        destination[offset + 6] = hi;
+        hi >>= 8;
+        destination[offset + 7] = hi;
+        return 8;
+    },
+    setFloat64LE(destination, offset, value) {
+        FLOAT[0] = value;
+        destination[offset] = FLOAT_BYTES[0];
+        destination[offset + 1] = FLOAT_BYTES[1];
+        destination[offset + 2] = FLOAT_BYTES[2];
+        destination[offset + 3] = FLOAT_BYTES[3];
+        destination[offset + 4] = FLOAT_BYTES[4];
+        destination[offset + 5] = FLOAT_BYTES[5];
+        destination[offset + 6] = FLOAT_BYTES[6];
+        destination[offset + 7] = FLOAT_BYTES[7];
+        return 8;
+    }
+};
+
 const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
 let PROCESS_UNIQUE = null;
-const kId = Symbol('id');
 class ObjectId extends BSONValue {
     get _bsontype() {
         return 'ObjectId';
@@ -2032,14 +2236,14 @@ class ObjectId extends BSONValue {
             workingId = inputId;
         }
         if (workingId == null || typeof workingId === 'number') {
-            this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
+            this.buffer = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
         }
         else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
-            this[kId] = ByteUtils.toLocalBufferType(workingId);
+            this.buffer = ByteUtils.toLocalBufferType(workingId);
         }
         else if (typeof workingId === 'string') {
             if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
-                this[kId] = ByteUtils.fromHex(workingId);
+                this.buffer = ByteUtils.fromHex(workingId);
             }
             else {
                 throw new BSONError('input must be a 24 character hex string, 12 byte Uint8Array, or an integer');
@@ -2053,10 +2257,10 @@ class ObjectId extends BSONValue {
         }
     }
     get id() {
-        return this[kId];
+        return this.buffer;
     }
     set id(value) {
-        this[kId] = value;
+        this.buffer = value;
         if (ObjectId.cacheHexString) {
             this.__id = ByteUtils.toHex(value);
         }
@@ -2079,8 +2283,8 @@ class ObjectId extends BSONValue {
             time = Math.floor(Date.now() / 1000);
         }
         const inc = ObjectId.getInc();
-        const buffer = ByteUtils.allocate(12);
-        BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
+        const buffer = ByteUtils.allocateUnsafe(12);
+        NumberUtils.setInt32BE(buffer, 0, time);
         if (PROCESS_UNIQUE === null) {
             PROCESS_UNIQUE = ByteUtils.randomBytes(5);
         }
@@ -2115,7 +2319,7 @@ class ObjectId extends BSONValue {
             return false;
         }
         if (ObjectId.is(otherId)) {
-            return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);
+            return (this.buffer[11] === otherId.buffer[11] && ByteUtils.equals(this.buffer, otherId.buffer));
         }
         if (typeof otherId === 'string') {
             return otherId.toLowerCase() === this.toHexString();
@@ -2129,16 +2333,33 @@ class ObjectId extends BSONValue {
     }
     getTimestamp() {
         const timestamp = new Date();
-        const time = BSONDataView.fromUint8Array(this.id).getUint32(0, false);
+        const time = NumberUtils.getUint32BE(this.buffer, 0);
         timestamp.setTime(Math.floor(time) * 1000);
         return timestamp;
     }
     static createPk() {
         return new ObjectId();
     }
+    serializeInto(uint8array, index) {
+        uint8array[index] = this.buffer[0];
+        uint8array[index + 1] = this.buffer[1];
+        uint8array[index + 2] = this.buffer[2];
+        uint8array[index + 3] = this.buffer[3];
+        uint8array[index + 4] = this.buffer[4];
+        uint8array[index + 5] = this.buffer[5];
+        uint8array[index + 6] = this.buffer[6];
+        uint8array[index + 7] = this.buffer[7];
+        uint8array[index + 8] = this.buffer[8];
+        uint8array[index + 9] = this.buffer[9];
+        uint8array[index + 10] = this.buffer[10];
+        uint8array[index + 11] = this.buffer[11];
+        return 12;
+    }
     static createFromTime(time) {
-        const buffer = ByteUtils.fromNumberArray([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
-        BSONDataView.fromUint8Array(buffer).setUint32(0, time, false);
+        const buffer = ByteUtils.allocate(12);
+        for (let i = 11; i >= 4; i--)
+            buffer[i] = 0;
+        NumberUtils.setInt32BE(buffer, 0, time);
         return new ObjectId(buffer);
     }
     static createFromHexString(hexString) {
@@ -2505,52 +2726,12 @@ class Timestamp extends LongWithoutOverridesClass {
 }
 Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 
-const FIRST_BIT = 0x80;
-const FIRST_TWO_BITS = 0xc0;
-const FIRST_THREE_BITS = 0xe0;
-const FIRST_FOUR_BITS = 0xf0;
-const FIRST_FIVE_BITS = 0xf8;
-const TWO_BIT_CHAR = 0xc0;
-const THREE_BIT_CHAR = 0xe0;
-const FOUR_BIT_CHAR = 0xf0;
-const CONTINUING_CHAR = 0x80;
-function validateUtf8(bytes, start, end) {
-    let continuation = 0;
-    for (let i = start; i < end; i += 1) {
-        const byte = bytes[i];
-        if (continuation) {
-            if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {
-                return false;
-            }
-            continuation -= 1;
-        }
-        else if (byte & FIRST_BIT) {
-            if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {
-                continuation = 1;
-            }
-            else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {
-                continuation = 2;
-            }
-            else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {
-                continuation = 3;
-            }
-            else {
-                return false;
-            }
-        }
-    }
-    return !continuation;
-}
-
 const JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX);
 const JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN);
 function internalDeserialize(buffer, options, isArray) {
     options = options == null ? {} : options;
     const index = options && options.index ? options.index : 0;
-    const size = buffer[index] |
-        (buffer[index + 1] << 8) |
-        (buffer[index + 2] << 16) |
-        (buffer[index + 3] << 24);
+    const size = NumberUtils.getInt32LE(buffer, index);
     if (size < 5) {
         throw new BSONError(`bson size must be >= 5, is ${size}`);
     }
@@ -2586,7 +2767,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
     const validation = options.validation == null ? { utf8: true } : options.validation;
     let globalUTFValidation = true;
     let validationSetting;
-    const utf8KeysSet = new Set();
+    let utf8KeysSet;
     const utf8ValidatedKeys = validation.utf8;
     if (typeof utf8ValidatedKeys === 'boolean') {
         validationSetting = utf8ValidatedKeys;
@@ -2608,6 +2789,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
     }
     if (!globalUTFValidation) {
+        utf8KeysSet = new Set();
         for (const key of Object.keys(utf8ValidatedKeys)) {
             utf8KeysSet.add(key);
         }
@@ -2615,14 +2797,14 @@ function deserializeObject(buffer, index, options, isArray = false) {
     const startIndex = index;
     if (buffer.length < 5)
         throw new BSONError('corrupt bson message < 5 bytes long');
-    const size = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
+    const size = NumberUtils.getInt32LE(buffer, index);
+    index += 4;
     if (size < 5 || size > buffer.length)
         throw new BSONError('corrupt bson message');
     const object = isArray ? [] : {};
     let arrayIndex = 0;
     const done = false;
     let isPossibleDBRef = isArray ? false : null;
-    const dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
     while (!done) {
         const elementType = buffer[index++];
         if (elementType === 0)
@@ -2633,9 +2815,9 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
         if (i >= buffer.byteLength)
             throw new BSONError('Bad BSON Document: illegal CString');
-        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i);
+        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i, false);
         let shouldValidateKey = true;
-        if (globalUTFValidation || utf8KeysSet.has(name)) {
+        if (globalUTFValidation || utf8KeysSet?.has(name)) {
             shouldValidateKey = validationSetting;
         }
         else {
@@ -2647,51 +2829,41 @@ function deserializeObject(buffer, index, options, isArray = false) {
         let value;
         index = i + 1;
         if (elementType === BSON_DATA_STRING) {
-            const stringSize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const stringSize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             if (stringSize <= 0 ||
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            value = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            value = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             index = index + stringSize;
         }
         else if (elementType === BSON_DATA_OID) {
-            const oid = ByteUtils.allocate(12);
-            oid.set(buffer.subarray(index, index + 12));
+            const oid = ByteUtils.allocateUnsafe(12);
+            for (let i = 0; i < 12; i++)
+                oid[i] = buffer[index + i];
             value = new ObjectId(oid);
             index = index + 12;
         }
         else if (elementType === BSON_DATA_INT && promoteValues === false) {
-            value = new Int32(buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24));
+            value = new Int32(NumberUtils.getInt32LE(buffer, index));
+            index += 4;
         }
         else if (elementType === BSON_DATA_INT) {
-            value =
-                buffer[index++] |
-                    (buffer[index++] << 8) |
-                    (buffer[index++] << 16) |
-                    (buffer[index++] << 24);
-        }
-        else if (elementType === BSON_DATA_NUMBER && promoteValues === false) {
-            value = new Double(dataview.getFloat64(index, true));
-            index = index + 8;
+            value = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
         }
         else if (elementType === BSON_DATA_NUMBER) {
-            value = dataview.getFloat64(index, true);
-            index = index + 8;
+            value = NumberUtils.getFloat64LE(buffer, index);
+            index += 8;
+            if (promoteValues === false)
+                value = new Double(value);
         }
         else if (elementType === BSON_DATA_DATE) {
-            const lowBits = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
-            const highBits = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const lowBits = NumberUtils.getInt32LE(buffer, index);
+            const highBits = NumberUtils.getInt32LE(buffer, index + 4);
+            index += 8;
             value = new Date(new Long(lowBits, highBits).toNumber());
         }
         else if (elementType === BSON_DATA_BOOLEAN) {
@@ -2701,10 +2873,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
         else if (elementType === BSON_DATA_OBJECT) {
             const _index = index;
-            const objectSize = buffer[index] |
-                (buffer[index + 1] << 8) |
-                (buffer[index + 2] << 16) |
-                (buffer[index + 3] << 24);
+            const objectSize = NumberUtils.getInt32LE(buffer, index);
             if (objectSize <= 0 || objectSize > buffer.length - index)
                 throw new BSONError('bad embedded document length in bson');
             if (raw) {
@@ -2721,10 +2890,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
         else if (elementType === BSON_DATA_ARRAY) {
             const _index = index;
-            const objectSize = buffer[index] |
-                (buffer[index + 1] << 8) |
-                (buffer[index + 2] << 16) |
-                (buffer[index + 3] << 24);
+            const objectSize = NumberUtils.getInt32LE(buffer, index);
             let arrayOptions = options;
             const stopIndex = index + objectSize;
             if (fieldsAsRaw && fieldsAsRaw[name]) {
@@ -2747,40 +2913,36 @@ function deserializeObject(buffer, index, options, isArray = false) {
             value = null;
         }
         else if (elementType === BSON_DATA_LONG) {
-            const dataview = BSONDataView.fromUint8Array(buffer.subarray(index, index + 8));
-            const lowBits = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
-            const highBits = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
-            const long = new Long(lowBits, highBits);
             if (useBigInt64) {
-                value = dataview.getBigInt64(0, true);
-            }
-            else if (promoteLongs && promoteValues === true) {
-                value =
-                    long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
-                        ? long.toNumber()
-                        : long;
+                value = NumberUtils.getBigInt64LE(buffer, index);
+                index += 8;
             }
             else {
-                value = long;
+                const lowBits = NumberUtils.getInt32LE(buffer, index);
+                const highBits = NumberUtils.getInt32LE(buffer, index + 4);
+                index += 8;
+                const long = new Long(lowBits, highBits);
+                if (promoteLongs && promoteValues === true) {
+                    value =
+                        long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
+                            ? long.toNumber()
+                            : long;
+                }
+                else {
+                    value = long;
+                }
             }
         }
         else if (elementType === BSON_DATA_DECIMAL128) {
-            const bytes = ByteUtils.allocate(16);
-            bytes.set(buffer.subarray(index, index + 16), 0);
+            const bytes = ByteUtils.allocateUnsafe(16);
+            for (let i = 0; i < 16; i++)
+                bytes[i] = buffer[index + i];
             index = index + 16;
             value = new Decimal128(bytes);
         }
         else if (elementType === BSON_DATA_BINARY) {
-            let binarySize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            let binarySize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             const totalBinarySize = binarySize;
             const subType = buffer[index++];
             if (binarySize < 0)
@@ -2789,11 +2951,8 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 throw new BSONError('Binary type size larger than document size');
             if (buffer['slice'] != null) {
                 if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-                    binarySize =
-                        buffer[index++] |
-                            (buffer[index++] << 8) |
-                            (buffer[index++] << 16) |
-                            (buffer[index++] << 24);
+                    binarySize = NumberUtils.getInt32LE(buffer, index);
+                    index += 4;
                     if (binarySize < 0)
                         throw new BSONError('Negative binary type element size found for subtype 0x02');
                     if (binarySize > totalBinarySize - 4)
@@ -2812,13 +2971,9 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 }
             }
             else {
-                const _buffer = ByteUtils.allocate(binarySize);
                 if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-                    binarySize =
-                        buffer[index++] |
-                            (buffer[index++] << 8) |
-                            (buffer[index++] << 16) |
-                            (buffer[index++] << 24);
+                    binarySize = NumberUtils.getInt32LE(buffer, index);
+                    index += 4;
                     if (binarySize < 0)
                         throw new BSONError('Negative binary type element size found for subtype 0x02');
                     if (binarySize > totalBinarySize - 4)
@@ -2826,11 +2981,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
                     if (binarySize < totalBinarySize - 4)
                         throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
                 }
-                for (i = 0; i < binarySize; i++) {
-                    _buffer[i] = buffer[index + i];
-                }
                 if (promoteBuffers && promoteValues) {
-                    value = _buffer;
+                    value = ByteUtils.allocateUnsafe(binarySize);
+                    for (i = 0; i < binarySize; i++) {
+                        value[i] = buffer[index + i];
+                    }
                 }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
@@ -2848,7 +3003,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const source = ByteUtils.toUTF8(buffer, index, i);
+            const source = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2856,7 +3011,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             const optionsArray = new Array(regExpOptions.length);
             for (i = 0; i < regExpOptions.length; i++) {
@@ -2881,7 +3036,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const source = ByteUtils.toUTF8(buffer, index, i);
+            const source = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2889,34 +3044,28 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             value = new BSONRegExp(source, regExpOptions);
         }
         else if (elementType === BSON_DATA_SYMBOL) {
-            const stringSize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const stringSize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             if (stringSize <= 0 ||
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            const symbol = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            const symbol = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             value = promoteValues ? symbol : new BSONSymbol(symbol);
             index = index + stringSize;
         }
         else if (elementType === BSON_DATA_TIMESTAMP) {
-            const i = buffer[index++] +
-                buffer[index++] * (1 << 8) +
-                buffer[index++] * (1 << 16) +
-                buffer[index++] * (1 << 24);
-            const t = buffer[index++] +
-                buffer[index++] * (1 << 8) +
-                buffer[index++] * (1 << 16) +
-                buffer[index++] * (1 << 24);
-            value = new Timestamp({ i, t });
+            value = new Timestamp({
+                i: NumberUtils.getUint32LE(buffer, index),
+                t: NumberUtils.getUint32LE(buffer, index + 4)
+            });
+            index += 8;
         }
         else if (elementType === BSON_DATA_MIN_KEY) {
             value = new MinKey();
@@ -2925,43 +3074,34 @@ function deserializeObject(buffer, index, options, isArray = false) {
             value = new MaxKey();
         }
         else if (elementType === BSON_DATA_CODE) {
-            const stringSize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const stringSize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             if (stringSize <= 0 ||
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            const functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            const functionString = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             value = new Code(functionString);
             index = index + stringSize;
         }
         else if (elementType === BSON_DATA_CODE_W_SCOPE) {
-            const totalSize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const totalSize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             if (totalSize < 4 + 4 + 4 + 1) {
                 throw new BSONError('code_w_scope total size shorter minimum expected length');
             }
-            const stringSize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const stringSize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             if (stringSize <= 0 ||
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            const functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            const functionString = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             index = index + stringSize;
             const _index = index;
-            const objectSize = buffer[index] |
-                (buffer[index + 1] << 8) |
-                (buffer[index + 2] << 16) |
-                (buffer[index + 3] << 24);
+            const objectSize = NumberUtils.getInt32LE(buffer, index);
             const scopeObject = deserializeObject(buffer, _index, options, false);
             index = index + objectSize;
             if (totalSize < 4 + 4 + objectSize + stringSize) {
@@ -2973,10 +3113,8 @@ function deserializeObject(buffer, index, options, isArray = false) {
             value = new Code(functionString, scopeObject);
         }
         else if (elementType === BSON_DATA_DBPOINTER) {
-            const stringSize = buffer[index++] |
-                (buffer[index++] << 8) |
-                (buffer[index++] << 16) |
-                (buffer[index++] << 24);
+            const stringSize = NumberUtils.getInt32LE(buffer, index);
+            index += 4;
             if (stringSize <= 0 ||
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0)
@@ -2986,10 +3124,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
                     throw new BSONError('Invalid UTF-8 string in BSON document');
                 }
             }
-            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);
+            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, false);
             index = index + stringSize;
-            const oidBuffer = ByteUtils.allocate(12);
-            oidBuffer.set(buffer.subarray(index, index + 12), 0);
+            const oidBuffer = ByteUtils.allocateUnsafe(12);
+            for (let i = 0; i < 12; i++)
+                oidBuffer[i] = buffer[index + i];
             const oid = new ObjectId(oidBuffer);
             index = index + 12;
             value = new DBRef(namespace, oid);
@@ -3025,20 +3164,6 @@ function deserializeObject(buffer, index, options, isArray = false) {
     }
     return object;
 }
-function getValidatedString(buffer, start, end, shouldValidateUtf8) {
-    const value = ByteUtils.toUTF8(buffer, start, end);
-    if (shouldValidateUtf8) {
-        for (let i = 0; i < value.length; i++) {
-            if (value.charCodeAt(i) === 0xfffd) {
-                if (!validateUtf8(buffer, start, end)) {
-                    throw new BSONError('Invalid UTF-8 string in BSON document');
-                }
-                break;
-            }
-        }
-    }
-    return value;
-}
 
 const regexp = /\x00/;
 const ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);
@@ -3048,17 +3173,11 @@ function serializeString(buffer, key, value, index) {
     index = index + numberOfWrittenBytes + 1;
     buffer[index - 1] = 0;
     const size = ByteUtils.encodeUTF8Into(buffer, value, index + 4);
-    buffer[index + 3] = ((size + 1) >> 24) & 0xff;
-    buffer[index + 2] = ((size + 1) >> 16) & 0xff;
-    buffer[index + 1] = ((size + 1) >> 8) & 0xff;
-    buffer[index] = (size + 1) & 0xff;
+    NumberUtils.setInt32LE(buffer, index, size + 1);
     index = index + 4 + size;
     buffer[index++] = 0;
     return index;
 }
-const NUMBER_SPACE = new DataView(new ArrayBuffer(8), 0, 8);
-const FOUR_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 4);
-const EIGHT_BYTE_VIEW_ON_NUMBER = new Uint8Array(NUMBER_SPACE.buffer, 0, 8);
 function serializeNumber(buffer, key, value, index) {
     const isNegativeZero = Object.is(value, -0);
     const type = !isNegativeZero &&
@@ -3067,19 +3186,16 @@ function serializeNumber(buffer, key, value, index) {
         value >= BSON_INT32_MIN
         ? BSON_DATA_INT
         : BSON_DATA_NUMBER;
-    if (type === BSON_DATA_INT) {
-        NUMBER_SPACE.setInt32(0, value, true);
-    }
-    else {
-        NUMBER_SPACE.setFloat64(0, value, true);
-    }
-    const bytes = type === BSON_DATA_INT ? FOUR_BYTE_VIEW_ON_NUMBER : EIGHT_BYTE_VIEW_ON_NUMBER;
     buffer[index++] = type;
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0x00;
-    buffer.set(bytes, index);
-    index += bytes.byteLength;
+    if (type === BSON_DATA_INT) {
+        index += NumberUtils.setInt32LE(buffer, index, value);
+    }
+    else {
+        index += NumberUtils.setFloat64LE(buffer, index, value);
+    }
     return index;
 }
 function serializeBigInt(buffer, key, value, index) {
@@ -3087,9 +3203,7 @@ function serializeBigInt(buffer, key, value, index) {
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index += numberOfWrittenBytes;
     buffer[index++] = 0;
-    NUMBER_SPACE.setBigInt64(0, value, true);
-    buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
-    index += EIGHT_BYTE_VIEW_ON_NUMBER.byteLength;
+    index += NumberUtils.setBigInt64LE(buffer, index, value);
     return index;
 }
 function serializeNull(buffer, key, _, index) {
@@ -3115,14 +3229,8 @@ function serializeDate(buffer, key, value, index) {
     const dateInMilis = Long.fromNumber(value.getTime());
     const lowBits = dateInMilis.getLowBits();
     const highBits = dateInMilis.getHighBits();
-    buffer[index++] = lowBits & 0xff;
-    buffer[index++] = (lowBits >> 8) & 0xff;
-    buffer[index++] = (lowBits >> 16) & 0xff;
-    buffer[index++] = (lowBits >> 24) & 0xff;
-    buffer[index++] = highBits & 0xff;
-    buffer[index++] = (highBits >> 8) & 0xff;
-    buffer[index++] = (highBits >> 16) & 0xff;
-    buffer[index++] = (highBits >> 24) & 0xff;
+    index += NumberUtils.setInt32LE(buffer, index, lowBits);
+    index += NumberUtils.setInt32LE(buffer, index, highBits);
     return index;
 }
 function serializeRegExp(buffer, key, value, index) {
@@ -3179,15 +3287,7 @@ function serializeObjectId(buffer, key, value, index) {
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
-    const idValue = value.id;
-    if (isUint8Array(idValue)) {
-        for (let i = 0; i < 12; i++) {
-            buffer[index++] = idValue[i];
-        }
-    }
-    else {
-        throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
-    }
+    index += value.serializeInto(buffer, index);
     return index;
 }
 function serializeBuffer(buffer, key, value, index) {
@@ -3196,12 +3296,15 @@ function serializeBuffer(buffer, key, value, index) {
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
     const size = value.length;
-    buffer[index++] = size & 0xff;
-    buffer[index++] = (size >> 8) & 0xff;
-    buffer[index++] = (size >> 16) & 0xff;
-    buffer[index++] = (size >> 24) & 0xff;
+    index += NumberUtils.setInt32LE(buffer, index, size);
     buffer[index++] = BSON_BINARY_SUBTYPE_DEFAULT;
-    buffer.set(value, index);
+    if (size <= 16) {
+        for (let i = 0; i < size; i++)
+            buffer[index + i] = value[i];
+    }
+    else {
+        buffer.set(value, index);
+    }
     index = index + size;
     return index;
 }
@@ -3223,7 +3326,8 @@ function serializeDecimal128(buffer, key, value, index) {
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
-    buffer.set(value.bytes.subarray(0, 16), index);
+    for (let i = 0; i < 16; i++)
+        buffer[index + i] = value.bytes[i];
     return index + 16;
 }
 function serializeLong(buffer, key, value, index) {
@@ -3234,14 +3338,8 @@ function serializeLong(buffer, key, value, index) {
     buffer[index++] = 0;
     const lowBits = value.getLowBits();
     const highBits = value.getHighBits();
-    buffer[index++] = lowBits & 0xff;
-    buffer[index++] = (lowBits >> 8) & 0xff;
-    buffer[index++] = (lowBits >> 16) & 0xff;
-    buffer[index++] = (lowBits >> 24) & 0xff;
-    buffer[index++] = highBits & 0xff;
-    buffer[index++] = (highBits >> 8) & 0xff;
-    buffer[index++] = (highBits >> 16) & 0xff;
-    buffer[index++] = (highBits >> 24) & 0xff;
+    index += NumberUtils.setInt32LE(buffer, index, lowBits);
+    index += NumberUtils.setInt32LE(buffer, index, highBits);
     return index;
 }
 function serializeInt32(buffer, key, value, index) {
@@ -3250,10 +3348,7 @@ function serializeInt32(buffer, key, value, index) {
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
-    buffer[index++] = value & 0xff;
-    buffer[index++] = (value >> 8) & 0xff;
-    buffer[index++] = (value >> 16) & 0xff;
-    buffer[index++] = (value >> 24) & 0xff;
+    index += NumberUtils.setInt32LE(buffer, index, value);
     return index;
 }
 function serializeDouble(buffer, key, value, index) {
@@ -3261,9 +3356,7 @@ function serializeDouble(buffer, key, value, index) {
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
-    NUMBER_SPACE.setFloat64(0, value.value, true);
-    buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
-    index = index + 8;
+    index += NumberUtils.setFloat64LE(buffer, index, value.value);
     return index;
 }
 function serializeFunction(buffer, key, value, index) {
@@ -3273,10 +3366,7 @@ function serializeFunction(buffer, key, value, index) {
     buffer[index++] = 0;
     const functionString = value.toString();
     const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
-    buffer[index] = size & 0xff;
-    buffer[index + 1] = (size >> 8) & 0xff;
-    buffer[index + 2] = (size >> 16) & 0xff;
-    buffer[index + 3] = (size >> 24) & 0xff;
+    NumberUtils.setInt32LE(buffer, index, size);
     index = index + 4 + size - 1;
     buffer[index++] = 0;
     return index;
@@ -3291,19 +3381,13 @@ function serializeCode(buffer, key, value, index, checkKeys = false, depth = 0,
         const functionString = value.code;
         index = index + 4;
         const codeSize = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
-        buffer[index] = codeSize & 0xff;
-        buffer[index + 1] = (codeSize >> 8) & 0xff;
-        buffer[index + 2] = (codeSize >> 16) & 0xff;
-        buffer[index + 3] = (codeSize >> 24) & 0xff;
+        NumberUtils.setInt32LE(buffer, index, codeSize);
         buffer[index + 4 + codeSize - 1] = 0;
         index = index + codeSize + 4;
         const endIndex = serializeInto(buffer, value.scope, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path);
         index = endIndex - 1;
         const totalSize = endIndex - startIndex;
-        buffer[startIndex++] = totalSize & 0xff;
-        buffer[startIndex++] = (totalSize >> 8) & 0xff;
-        buffer[startIndex++] = (totalSize >> 16) & 0xff;
-        buffer[startIndex++] = (totalSize >> 24) & 0xff;
+        startIndex += NumberUtils.setInt32LE(buffer, startIndex, totalSize);
         buffer[index++] = 0;
     }
     else {
@@ -3313,10 +3397,7 @@ function serializeCode(buffer, key, value, index, checkKeys = false, depth = 0,
         buffer[index++] = 0;
         const functionString = value.code.toString();
         const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
-        buffer[index] = size & 0xff;
-        buffer[index + 1] = (size >> 8) & 0xff;
-        buffer[index + 2] = (size >> 16) & 0xff;
-        buffer[index + 3] = (size >> 24) & 0xff;
+        NumberUtils.setInt32LE(buffer, index, size);
         index = index + 4 + size - 1;
         buffer[index++] = 0;
     }
@@ -3331,19 +3412,19 @@ function serializeBinary(buffer, key, value, index) {
     let size = value.position;
     if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY)
         size = size + 4;
-    buffer[index++] = size & 0xff;
-    buffer[index++] = (size >> 8) & 0xff;
-    buffer[index++] = (size >> 16) & 0xff;
-    buffer[index++] = (size >> 24) & 0xff;
+    index += NumberUtils.setInt32LE(buffer, index, size);
     buffer[index++] = value.sub_type;
     if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
         size = size - 4;
-        buffer[index++] = size & 0xff;
-        buffer[index++] = (size >> 8) & 0xff;
-        buffer[index++] = (size >> 16) & 0xff;
-        buffer[index++] = (size >> 24) & 0xff;
+        index += NumberUtils.setInt32LE(buffer, index, size);
+    }
+    if (size <= 16) {
+        for (let i = 0; i < size; i++)
+            buffer[index + i] = data[i];
+    }
+    else {
+        buffer.set(data, index);
     }
-    buffer.set(data, index);
     index = index + value.position;
     return index;
 }
@@ -3353,12 +3434,9 @@ function serializeSymbol(buffer, key, value, index) {
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
     const size = ByteUtils.encodeUTF8Into(buffer, value.value, index + 4) + 1;
-    buffer[index] = size & 0xff;
-    buffer[index + 1] = (size >> 8) & 0xff;
-    buffer[index + 2] = (size >> 16) & 0xff;
-    buffer[index + 3] = (size >> 24) & 0xff;
+    NumberUtils.setInt32LE(buffer, index, size);
     index = index + 4 + size - 1;
-    buffer[index++] = 0x00;
+    buffer[index++] = 0;
     return index;
 }
 function serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path) {
@@ -3377,10 +3455,7 @@ function serializeDBRef(buffer, key, value, index, depth, serializeFunctions, pa
     output = Object.assign(output, value.fields);
     const endIndex = serializeInto(buffer, output, false, index, depth + 1, serializeFunctions, true, path);
     const size = endIndex - startIndex;
-    buffer[startIndex++] = size & 0xff;
-    buffer[startIndex++] = (size >> 8) & 0xff;
-    buffer[startIndex++] = (size >> 16) & 0xff;
-    buffer[startIndex++] = (size >> 24) & 0xff;
+    startIndex += NumberUtils.setInt32LE(buffer, index, size);
     return endIndex;
 }
 function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializeFunctions, ignoreUndefined, path) {
@@ -3516,7 +3591,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                     if ('$' === key[0]) {
                         throw new BSONError('key ' + key + " must not start with '$'");
                     }
-                    else if (~key.indexOf('.')) {
+                    else if (key.includes('.')) {
                         throw new BSONError('key ' + key + " must not contain '.'");
                     }
                 }
@@ -3614,7 +3689,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                     if ('$' === key[0]) {
                         throw new BSONError('key ' + key + " must not start with '$'");
                     }
-                    else if (~key.indexOf('.')) {
+                    else if (key.includes('.')) {
                         throw new BSONError('key ' + key + " must not contain '.'");
                     }
                 }
@@ -3698,10 +3773,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
     path.delete(object);
     buffer[index++] = 0x00;
     const size = index - startingIndex;
-    buffer[startingIndex++] = size & 0xff;
-    buffer[startingIndex++] = (size >> 8) & 0xff;
-    buffer[startingIndex++] = (size >> 16) & 0xff;
-    buffer[startingIndex++] = (size >> 24) & 0xff;
+    startingIndex += NumberUtils.setInt32LE(buffer, startingIndex, size);
     return index;
 }
 
@@ -4031,7 +4103,7 @@ function serialize(object, options = {}) {
         buffer = ByteUtils.allocate(minInternalBufferSize);
     }
     const serializationIndex = serializeInto(buffer, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, null);
-    const finishedBuffer = ByteUtils.allocate(serializationIndex);
+    const finishedBuffer = ByteUtils.allocateUnsafe(serializationIndex);
     finishedBuffer.set(buffer.subarray(0, serializationIndex), 0);
     return finishedBuffer;
 }
@@ -4058,10 +4130,7 @@ function deserializeStream(data, startIndex, numberOfDocuments, documents, docSt
     const bufferData = ByteUtils.toLocalBufferType(data);
     let index = startIndex;
     for (let i = 0; i < numberOfDocuments; i++) {
-        const size = bufferData[index] |
-            (bufferData[index + 1] << 8) |
-            (bufferData[index + 2] << 16) |
-            (bufferData[index + 3] << 24);
+        const size = NumberUtils.getInt32LE(bufferData, index);
         internalOptions.index = index;
         documents[docStartIndex + i] = internalDeserialize(bufferData, internalOptions);
         index = index + size;