bson 6.3.0 → 6.5.0

package/lib/bson.bundle.js

@@ -127,6 +127,15 @@ class BSONRuntimeError extends BSONError {
         super(message);
     }
 }
+class BSONOffsetError extends BSONError {
+    get name() {
+        return 'BSONOffsetError';
+    }
+    constructor(message, offset) {
+        super(`${message}. offset: ${offset}`);
+        this.offset = offset;
+    }
+}
 
 const FIRST_BIT = 0x80;
 const FIRST_TWO_BITS = 0xc0;
@@ -165,7 +174,7 @@ function validateUtf8(bytes, start, end) {
     return !continuation;
 }
 
-function tryLatin(uint8array, start, end) {
+function tryReadBasicLatin(uint8array, start, end) {
     if (uint8array.length === 0) {
         return '';
     }
@@ -200,6 +209,21 @@ function tryLatin(uint8array, start, end) {
     }
     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)));
@@ -232,6 +256,9 @@ const nodeJsByteUtils = {
     allocate(size) {
         return Buffer.alloc(size);
     },
+    allocateUnsafe(size) {
+        return Buffer.allocUnsafe(size);
+    },
     equals(a, b) {
         return nodeJsByteUtils.toLocalBufferType(a).equals(b);
     },
@@ -256,11 +283,8 @@ const nodeJsByteUtils = {
     toHex(buffer) {
         return nodeJsByteUtils.toLocalBufferType(buffer).toString('hex');
     },
-    fromUTF8(text) {
-        return Buffer.from(text, 'utf8');
-    },
     toUTF8(buffer, start, end, fatal) {
-        const basicLatin = end - start <= 20 ? tryLatin(buffer, start, end) : null;
+        const basicLatin = end - start <= 20 ? tryReadBasicLatin(buffer, start, end) : null;
         if (basicLatin != null) {
             return basicLatin;
         }
@@ -281,6 +305,10 @@ const nodeJsByteUtils = {
         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
@@ -336,6 +364,9 @@ const webByteUtils = {
         }
         return new Uint8Array(size);
     },
+    allocateUnsafe(size) {
+        return webByteUtils.allocate(size);
+    },
     equals(a, b) {
         if (a.byteLength !== b.byteLength) {
             return false;
@@ -382,11 +413,8 @@ 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, fatal) {
-        const basicLatin = end - start <= 20 ? tryLatin(uint8array, start, end) : null;
+        const basicLatin = end - start <= 20 ? tryReadBasicLatin(uint8array, start, end) : null;
         if (basicLatin != null) {
             return basicLatin;
         }
@@ -401,11 +429,11 @@ const webByteUtils = {
         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
@@ -413,11 +441,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')]() {
@@ -594,6 +617,7 @@ Binary.SUBTYPE_UUID = 4;
 Binary.SUBTYPE_MD5 = 5;
 Binary.SUBTYPE_ENCRYPTED = 6;
 Binary.SUBTYPE_COLUMN = 7;
+Binary.SUBTYPE_SENSITIVE = 8;
 Binary.SUBTYPE_USER_DEFINED = 128;
 const UUID_BYTE_LENGTH = 16;
 const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
@@ -1837,7 +1861,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;
@@ -2110,9 +2134,126 @@ class MinKey extends BSONValue {
     }
 }
 
+const FLOAT = new Float64Array(1);
+const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+FLOAT[0] = -1;
+const isBigEndian = FLOAT_BYTES[7] === 0;
+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: isBigEndian
+        ? (source, offset) => {
+            FLOAT_BYTES[7] = source[offset];
+            FLOAT_BYTES[6] = source[offset + 1];
+            FLOAT_BYTES[5] = source[offset + 2];
+            FLOAT_BYTES[4] = source[offset + 3];
+            FLOAT_BYTES[3] = source[offset + 4];
+            FLOAT_BYTES[2] = source[offset + 5];
+            FLOAT_BYTES[1] = source[offset + 6];
+            FLOAT_BYTES[0] = source[offset + 7];
+            return FLOAT[0];
+        }
+        : (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: isBigEndian
+        ? (destination, offset, value) => {
+            FLOAT[0] = value;
+            destination[offset] = FLOAT_BYTES[7];
+            destination[offset + 1] = FLOAT_BYTES[6];
+            destination[offset + 2] = FLOAT_BYTES[5];
+            destination[offset + 3] = FLOAT_BYTES[4];
+            destination[offset + 4] = FLOAT_BYTES[3];
+            destination[offset + 5] = FLOAT_BYTES[2];
+            destination[offset + 6] = FLOAT_BYTES[1];
+            destination[offset + 7] = FLOAT_BYTES[0];
+            return 8;
+        }
+        : (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';
@@ -2135,14 +2276,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');
@@ -2156,10 +2297,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);
         }
@@ -2182,8 +2323,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);
         }
@@ -2218,7 +2359,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();
@@ -2232,16 +2373,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) {
@@ -2613,10 +2771,7 @@ 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}`);
     }
@@ -2652,7 +2807,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;
@@ -2674,6 +2829,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
     }
     if (!globalUTFValidation) {
+        utf8KeysSet = new Set();
         for (const key of Object.keys(utf8ValidatedKeys)) {
             utf8KeysSet.add(key);
         }
@@ -2681,14 +2837,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)
@@ -2701,7 +2857,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             throw new BSONError('Bad BSON Document: illegal CString');
         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 {
@@ -2713,10 +2869,8 @@ 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) {
@@ -2726,38 +2880,30 @@ function deserializeObject(buffer, index, options, isArray = false) {
             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) {
@@ -2767,10 +2913,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) {
@@ -2787,10 +2930,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]) {
@@ -2813,40 +2953,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)
@@ -2855,11 +2991,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)
@@ -2878,13 +3011,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)
@@ -2892,11 +3021,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);
@@ -2960,10 +3089,8 @@ function deserializeObject(buffer, index, options, isArray = false) {
             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) {
@@ -2974,15 +3101,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
             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();
@@ -2991,10 +3114,8 @@ 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) {
@@ -3005,17 +3126,13 @@ function deserializeObject(buffer, index, options, isArray = false) {
             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) {
@@ -3024,10 +3141,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             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) {
@@ -3039,10 +3153,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)
@@ -3054,8 +3166,9 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             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);
@@ -3100,17 +3213,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 &&
@@ -3119,19 +3226,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) {
@@ -3139,9 +3243,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) {
@@ -3167,14 +3269,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) {
@@ -3231,15 +3327,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) {
@@ -3248,12 +3336,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;
 }
@@ -3275,7 +3366,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) {
@@ -3286,14 +3378,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) {
@@ -3302,10 +3388,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) {
@@ -3313,9 +3396,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) {
@@ -3325,10 +3406,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;
@@ -3343,19 +3421,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 {
@@ -3365,10 +3437,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;
     }
@@ -3383,19 +3452,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;
 }
@@ -3405,12 +3474,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) {
@@ -3429,10 +3495,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) {
@@ -3568,7 +3631,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 '.'");
                     }
                 }
@@ -3666,7 +3729,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 '.'");
                     }
                 }
@@ -3750,10 +3813,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;
 }
 
@@ -4067,6 +4127,104 @@ EJSON.serialize = EJSONserialize;
 EJSON.deserialize = EJSONdeserialize;
 Object.freeze(EJSON);
 
+function getSize(source, offset) {
+    if (source[offset + 3] > 127) {
+        throw new BSONOffsetError('BSON size cannot be negative', offset);
+    }
+    return (source[offset] |
+        (source[offset + 1] << 8) |
+        (source[offset + 2] << 16) |
+        (source[offset + 3] << 24));
+}
+function findNull(bytes, offset) {
+    let nullTerminatorOffset = offset;
+    for (; bytes[nullTerminatorOffset] !== 0x00; nullTerminatorOffset++)
+        ;
+    if (nullTerminatorOffset === bytes.length - 1) {
+        throw new BSONOffsetError('Null terminator not found', offset);
+    }
+    return nullTerminatorOffset;
+}
+function parseToElements(bytes, startOffset = 0) {
+    if (bytes.length < 5) {
+        throw new BSONOffsetError(`Input must be at least 5 bytes, got ${bytes.length} bytes`, startOffset);
+    }
+    const documentSize = getSize(bytes, startOffset);
+    if (documentSize > bytes.length - startOffset) {
+        throw new BSONOffsetError(`Parsed documentSize (${documentSize} bytes) does not match input length (${bytes.length} bytes)`, startOffset);
+    }
+    if (bytes[startOffset + documentSize - 1] !== 0x00) {
+        throw new BSONOffsetError('BSON documents must end in 0x00', startOffset + documentSize);
+    }
+    const elements = [];
+    let offset = startOffset + 4;
+    while (offset <= documentSize + startOffset) {
+        const type = bytes[offset];
+        offset += 1;
+        if (type === 0) {
+            if (offset - startOffset !== documentSize) {
+                throw new BSONOffsetError(`Invalid 0x00 type byte`, offset);
+            }
+            break;
+        }
+        const nameOffset = offset;
+        const nameLength = findNull(bytes, offset) - nameOffset;
+        offset += nameLength + 1;
+        let length;
+        if (type === 1 || type === 18 || type === 9 || type === 17) {
+            length = 8;
+        }
+        else if (type === 16) {
+            length = 4;
+        }
+        else if (type === 7) {
+            length = 12;
+        }
+        else if (type === 19) {
+            length = 16;
+        }
+        else if (type === 8) {
+            length = 1;
+        }
+        else if (type === 10 || type === 6 || type === 127 || type === 255) {
+            length = 0;
+        }
+        else if (type === 11) {
+            length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset;
+        }
+        else if (type === 3 || type === 4 || type === 15) {
+            length = getSize(bytes, offset);
+        }
+        else if (type === 2 ||
+            type === 5 ||
+            type === 12 ||
+            type === 13 ||
+            type === 14) {
+            length = getSize(bytes, offset) + 4;
+            if (type === 5) {
+                length += 1;
+            }
+            if (type === 12) {
+                length += 12;
+            }
+        }
+        else {
+            throw new BSONOffsetError(`Invalid 0x${type.toString(16).padStart(2, '0')} type byte`, offset);
+        }
+        if (length > documentSize) {
+            throw new BSONOffsetError('value reports length larger than document', offset);
+        }
+        elements.push([type, nameOffset, nameLength, offset, length]);
+        offset += length;
+    }
+    return elements;
+}
+
+const onDemand = Object.create(null);
+onDemand.parseToElements = parseToElements;
+onDemand.BSONOffsetError = BSONOffsetError;
+Object.freeze(onDemand);
+
 const MAXSIZE = 1024 * 1024 * 17;
 let buffer = ByteUtils.allocate(MAXSIZE);
 function setInternalBufferSize(size) {
@@ -4083,7 +4241,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;
 }
@@ -4110,10 +4268,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;
@@ -4146,6 +4301,7 @@ UUID: UUID,
 calculateObjectSize: calculateObjectSize,
 deserialize: deserialize,
 deserializeStream: deserializeStream,
+onDemand: onDemand,
 serialize: serialize,
 serializeWithBufferAndIndex: serializeWithBufferAndIndex,
 setInternalBufferSize: setInternalBufferSize
@@ -4175,6 +4331,7 @@ exports.UUID = UUID;
 exports.calculateObjectSize = calculateObjectSize;
 exports.deserialize = deserialize;
 exports.deserializeStream = deserializeStream;
+exports.onDemand = onDemand;
 exports.serialize = serialize;
 exports.serializeWithBufferAndIndex = serializeWithBufferAndIndex;
 exports.setInternalBufferSize = setInternalBufferSize;