bson 6.10.3 → 7.0.0-alpha

package/README.md

@@ -230,7 +230,17 @@ try {
 
 ## React Native
 
-BSON vendors the required polyfills for `TextEncoder`, `TextDecoder`, `atob`, `btoa` imported from React Native and therefore doesn't expect users to polyfill these. One additional polyfill, `crypto.getRandomValues` is recommended and can be installed with the following command:
+js-bson requires the `atob`, `btoa` and `TextEncoder` globals.  Older versions of React Native did not support these global objects, and so 
+[js-bson v5.4.0](https://github.com/mongodb/js-bson/releases/tag/v5.4.0) added support for bundled polyfills for these globals.  Newer versions
+of Hermes includes these globals, and so the polyfills for are no longer needed in the js-bson package.
+
+If you find yourself on a version of React Native that does not have these globals, either:
+
+1. polyfill them yourself
+2. upgrade to a later version of hermes
+3. use a version of js-bson `>=5.4.0` and `<7.0.0`
+
+One additional polyfill, `crypto.getRandomValues` is recommended and can be installed with the following command:
 
 ```sh
 npm install --save react-native-get-random-values

package/bson.d.ts

@@ -12,7 +12,10 @@ export declare class Binary extends BSONValue {
     static readonly SUBTYPE_DEFAULT = 0;
     /** Function BSON type */
     static readonly SUBTYPE_FUNCTION = 1;
-    /** Byte Array BSON type */
+    /**
+     * Legacy default BSON Binary type
+     * @deprecated BSON Binary subtype 2 is deprecated in the BSON specification
+     */
     static readonly SUBTYPE_BYTE_ARRAY = 2;
     /** Deprecated UUID BSON type @deprecated Please use SUBTYPE_UUID */
     static readonly SUBTYPE_UUID_OLD = 3;
@@ -234,6 +237,8 @@ declare namespace BSON {
         BSONRegExp,
         Decimal128,
         BSONValue,
+        bsonType,
+        BSONTypeTag,
         BSONError,
         BSONVersionError,
         BSONRuntimeError,
@@ -408,10 +413,17 @@ export declare const BSONType: Readonly<{
 /** @public */
 export declare type BSONType = (typeof BSONType)[keyof typeof BSONType];
 
+/** @public */
+export declare const bsonType: unique symbol;
+
+/** @public */
+export declare type BSONTypeTag = 'BSONRegExp' | 'BSONSymbol' | 'ObjectId' | 'Binary' | 'Decimal128' | 'Double' | 'Int32' | 'Long' | 'MaxKey' | 'MinKey' | 'Timestamp' | 'Code' | 'DBRef';
+
 /** @public */
 export declare abstract class BSONValue {
     /** @public */
-    abstract get _bsontype(): string;
+    abstract get _bsontype(): BSONTypeTag;
+    get [bsonType](): this['_bsontype'];
     /* Excluded from this release type: [BSON_VERSION_SYMBOL] */
     /**
      * @public
@@ -1341,17 +1353,13 @@ declare const NumberUtils: NumberUtils;
  * @category BSONType
  */
 export declare class ObjectId extends BSONValue {
+    #private;
     get _bsontype(): 'ObjectId';
     /* Excluded from this release type: index */
     static cacheHexString: boolean;
     /* Excluded from this release type: buffer */
-    /**
-     * Create ObjectId from a number.
-     *
-     * @param inputId - A number.
-     * @deprecated Instead, use `static createFromTime()` to set a numeric value for the new ObjectId.
-     */
-    constructor(inputId: number);
+    /** To generate a new ObjectId, use ObjectId() with no argument. */
+    constructor();
     /**
      * Create ObjectId from a 24 character hex string.
      *
@@ -1376,14 +1384,12 @@ export declare class ObjectId extends BSONValue {
      * @param inputId - A 12 byte binary Buffer.
      */
     constructor(inputId: Uint8Array);
-    /** To generate a new ObjectId, use ObjectId() with no argument. */
-    constructor();
     /**
      * Implementation overload.
      *
      * @param inputId - All input types that are used in the constructor implementation.
      */
-    constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array);
+    constructor(inputId?: string | ObjectId | ObjectIdLike | Uint8Array);
     /**
      * The ObjectId bytes
      * @readonly
@@ -1436,7 +1442,7 @@ export declare class ObjectId extends BSONValue {
      * Checks if a value can be used to create a valid bson ObjectId
      * @param id - any JS value
      */
-    static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean;
+    static isValid(id: string | ObjectId | ObjectIdLike | Uint8Array): boolean;
     /* Excluded from this release type: toExtendedJSON */
     /* Excluded from this release type: fromExtendedJSON */
     /* Excluded from this release type: isCached */
@@ -1584,6 +1590,7 @@ declare function stringify(value: any, replacer?: (number | string)[] | ((this:
  */
 export declare class Timestamp extends LongWithoutOverridesClass {
     get _bsontype(): 'Timestamp';
+    get [bsonType](): 'Timestamp';
     static readonly MAX_VALUE: Long;
     /**
      * An incrementing ordinal for operations within a given second.
@@ -1643,7 +1650,7 @@ export declare interface TimestampExtended {
 }
 
 /** @public */
-export declare type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect';
+export declare type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect' | typeof bsonType;
 
 /**
  * A class representation of the BSON UUID type.

package/lib/bson.bundle.js

@@ -143,6 +143,7 @@ class BSONOffsetError extends BSONError {
     get name() {
         return 'BSONOffsetError';
     }
+    offset;
     constructor(message, offset, options) {
         super(`${message}. offset: ${offset}`, options);
         this.offset = offset;
@@ -219,11 +220,15 @@ function tryWriteBasicLatin(destination, source, offset) {
 function nodejsMathRandomBytes(byteLength) {
     return nodeJsByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
 }
+function nodejsSecureRandomBytes(byteLength) {
+    return crypto.getRandomValues(nodeJsByteUtils.allocate(byteLength));
+}
 const nodejsRandomBytes = (() => {
-    try {
-        return require('crypto').randomBytes;
+    const { crypto } = globalThis;
+    if (crypto != null && typeof crypto.getRandomValues === 'function') {
+        return nodejsSecureRandomBytes;
     }
-    catch {
+    else {
         return nodejsMathRandomBytes;
     }
 })();
@@ -442,7 +447,11 @@ const webByteUtils = {
 const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuffer !== true;
 const ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
 
+const bsonType = Symbol.for('@@mdb.bson.type');
 class BSONValue {
+    get [bsonType]() {
+        return this._bsontype;
+    }
     get [BSON_VERSION_SYMBOL]() {
         return BSON_MAJOR_VERSION;
     }
@@ -493,7 +502,7 @@ const NumberUtils = {
             source[offset + 1] * 256 +
             source[offset + 2] * 65536 +
             source[offset + 3] * 16777216);
-        return (hi << BigInt(32)) + lo;
+        return (hi << 32n) + lo;
     },
     getFloat64LE: isBigEndian
         ? (source, offset) => {
@@ -539,7 +548,7 @@ const NumberUtils = {
         return 4;
     },
     setBigInt64LE(destination, offset, value) {
-        const mask32bits = BigInt(0xffff_ffff);
+        const mask32bits = 0xffffffffn;
         let lo = Number(value & mask32bits);
         destination[offset] = lo;
         lo >>= 8;
@@ -548,7 +557,7 @@ const NumberUtils = {
         destination[offset + 2] = lo;
         lo >>= 8;
         destination[offset + 3] = lo;
-        let hi = Number((value >> BigInt(32)) & mask32bits);
+        let hi = Number((value >> 32n) & mask32bits);
         destination[offset + 4] = hi;
         hi >>= 8;
         destination[offset + 5] = hi;
@@ -589,6 +598,27 @@ class Binary extends BSONValue {
     get _bsontype() {
         return 'Binary';
     }
+    static BSON_BINARY_SUBTYPE_DEFAULT = 0;
+    static BUFFER_SIZE = 256;
+    static SUBTYPE_DEFAULT = 0;
+    static SUBTYPE_FUNCTION = 1;
+    static SUBTYPE_BYTE_ARRAY = 2;
+    static SUBTYPE_UUID_OLD = 3;
+    static SUBTYPE_UUID = 4;
+    static SUBTYPE_MD5 = 5;
+    static SUBTYPE_ENCRYPTED = 6;
+    static SUBTYPE_COLUMN = 7;
+    static SUBTYPE_SENSITIVE = 8;
+    static SUBTYPE_VECTOR = 9;
+    static SUBTYPE_USER_DEFINED = 128;
+    static VECTOR_TYPE = Object.freeze({
+        Int8: 0x03,
+        Float32: 0x27,
+        PackedBit: 0x10
+    });
+    buffer;
+    sub_type;
+    position;
     constructor(buffer, subType) {
         super();
         if (!(buffer == null) &&
@@ -751,6 +781,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.Int8) {
             throw new BSONError('Binary datatype field is not Int8');
         }
+        validateBinaryVector(this);
         return new Int8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
     }
     toFloat32Array() {
@@ -760,6 +791,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.Float32) {
             throw new BSONError('Binary datatype field is not Float32');
         }
+        validateBinaryVector(this);
         const floatBytes = new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
         if (NumberUtils.isBigEndian)
             ByteUtils.swap32(floatBytes);
@@ -772,6 +804,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
             throw new BSONError('Binary datatype field is not packed bit');
         }
+        validateBinaryVector(this);
         return new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
     }
     toBits() {
@@ -781,6 +814,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
             throw new BSONError('Binary datatype field is not packed bit');
         }
+        validateBinaryVector(this);
         const byteCount = this.length() - 2;
         const bitCount = byteCount * 8 - this.buffer[1];
         const bits = new Int8Array(bitCount);
@@ -799,7 +833,9 @@ class Binary extends BSONValue {
         buffer[1] = 0;
         const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
         buffer.set(intBytes, 2);
-        return new this(buffer, this.SUBTYPE_VECTOR);
+        const bin = new this(buffer, this.SUBTYPE_VECTOR);
+        validateBinaryVector(bin);
+        return bin;
     }
     static fromFloat32Array(array) {
         const binaryBytes = ByteUtils.allocate(array.byteLength + 2);
@@ -809,14 +845,18 @@ class Binary extends BSONValue {
         binaryBytes.set(floatBytes, 2);
         if (NumberUtils.isBigEndian)
             ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2));
-        return new this(binaryBytes, this.SUBTYPE_VECTOR);
+        const bin = new this(binaryBytes, this.SUBTYPE_VECTOR);
+        validateBinaryVector(bin);
+        return bin;
     }
     static fromPackedBits(array, padding = 0) {
         const buffer = ByteUtils.allocate(array.byteLength + 2);
         buffer[0] = Binary.VECTOR_TYPE.PackedBit;
         buffer[1] = padding;
         buffer.set(array, 2);
-        return new this(buffer, this.SUBTYPE_VECTOR);
+        const bin = new this(buffer, this.SUBTYPE_VECTOR);
+        validateBinaryVector(bin);
+        return bin;
     }
     static fromBits(bits) {
         const byteLength = (bits.length + 7) >>> 3;
@@ -838,24 +878,6 @@ class Binary extends BSONValue {
         return new this(bytes, Binary.SUBTYPE_VECTOR);
     }
 }
-Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
-Binary.BUFFER_SIZE = 256;
-Binary.SUBTYPE_DEFAULT = 0;
-Binary.SUBTYPE_FUNCTION = 1;
-Binary.SUBTYPE_BYTE_ARRAY = 2;
-Binary.SUBTYPE_UUID_OLD = 3;
-Binary.SUBTYPE_UUID = 4;
-Binary.SUBTYPE_MD5 = 5;
-Binary.SUBTYPE_ENCRYPTED = 6;
-Binary.SUBTYPE_COLUMN = 7;
-Binary.SUBTYPE_SENSITIVE = 8;
-Binary.SUBTYPE_VECTOR = 9;
-Binary.SUBTYPE_USER_DEFINED = 128;
-Binary.VECTOR_TYPE = Object.freeze({
-    Int8: 0x03,
-    Float32: 0x27,
-    PackedBit: 0x10
-});
 function validateBinaryVector(vector) {
     if (vector.sub_type !== Binary.SUBTYPE_VECTOR)
         return;
@@ -866,6 +888,11 @@ function validateBinaryVector(vector) {
         padding !== 0) {
         throw new BSONError('Invalid Vector: padding must be zero for int8 and float32 vectors');
     }
+    if (datatype === Binary.VECTOR_TYPE.Float32) {
+        if (size !== 0 && size - 2 !== 0 && (size - 2) % 4 !== 0) {
+            throw new BSONError('Invalid Vector: Float32 vector must contain a multiple of 4 bytes');
+        }
+    }
     if (datatype === Binary.VECTOR_TYPE.PackedBit && padding !== 0 && size === 2) {
         throw new BSONError('Invalid Vector: padding must be zero for packed bit vectors that are empty');
     }
@@ -987,6 +1014,8 @@ class Code extends BSONValue {
     get _bsontype() {
         return 'Code';
     }
+    code;
+    scope;
     constructor(code, scope) {
         super();
         this.code = code.toString();
@@ -1032,6 +1061,10 @@ class DBRef extends BSONValue {
     get _bsontype() {
         return 'DBRef';
     }
+    collection;
+    oid;
+    db;
+    fields;
     constructor(collection, oid, db, fields) {
         super();
         const parts = collection.split('.');
@@ -1141,6 +1174,9 @@ class Long extends BSONValue {
     get __isLong__() {
         return true;
     }
+    high;
+    low;
+    unsigned;
     constructor(lowOrValue = 0, highOrUnsigned, unsigned) {
         super();
         const unsignedBool = typeof highOrUnsigned === 'boolean' ? highOrUnsigned : Boolean(unsigned);
@@ -1154,6 +1190,15 @@ class Long extends BSONValue {
         this.high = res.high;
         this.unsigned = res.unsigned;
     }
+    static TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
+    static MAX_UNSIGNED_VALUE = Long.fromBits(0xffffffff | 0, 0xffffffff | 0, true);
+    static ZERO = Long.fromInt(0);
+    static UZERO = Long.fromInt(0, true);
+    static ONE = Long.fromInt(1);
+    static UONE = Long.fromInt(1, true);
+    static NEG_ONE = Long.fromInt(-1);
+    static MAX_VALUE = Long.fromBits(0xffffffff | 0, 0x7fffffff | 0, false);
+    static MIN_VALUE = Long.fromBits(0, 0x80000000 | 0, false);
     static fromBits(lowBits, highBits, unsigned) {
         return new Long(lowBits, highBits, unsigned);
     }
@@ -1194,7 +1239,7 @@ class Long extends BSONValue {
                 return Long.MAX_UNSIGNED_VALUE;
         }
         else {
-            if (value <= -9223372036854776e3)
+            if (value <= -TWO_PWR_63_DBL)
                 return Long.MIN_VALUE;
             if (value + 1 >= TWO_PWR_63_DBL)
                 return Long.MAX_VALUE;
@@ -1204,8 +1249,8 @@ class Long extends BSONValue {
         return Long.fromBits(value % TWO_PWR_32_DBL | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);
     }
     static fromBigInt(value, unsigned) {
-        const FROM_BIGINT_BIT_MASK = BigInt(0xffffffff);
-        const FROM_BIGINT_BIT_SHIFT = BigInt(32);
+        const FROM_BIGINT_BIT_MASK = 0xffffffffn;
+        const FROM_BIGINT_BIT_SHIFT = 32n;
         return new Long(Number(value & FROM_BIGINT_BIT_MASK), Number((value >> FROM_BIGINT_BIT_SHIFT) & FROM_BIGINT_BIT_MASK), unsigned);
     }
     static _fromString(str, unsigned, radix) {
@@ -1238,7 +1283,7 @@ class Long extends BSONValue {
     static fromStringStrict(str, unsignedOrRadix, radix) {
         let unsigned = false;
         if (typeof unsignedOrRadix === 'number') {
-            (radix = unsignedOrRadix), (unsignedOrRadix = false);
+            ((radix = unsignedOrRadix), (unsignedOrRadix = false));
         }
         else {
             unsigned = !!unsignedOrRadix;
@@ -1260,7 +1305,7 @@ class Long extends BSONValue {
     static fromString(str, unsignedOrRadix, radix) {
         let unsigned = false;
         if (typeof unsignedOrRadix === 'number') {
-            (radix = unsignedOrRadix), (unsignedOrRadix = false);
+            ((radix = unsignedOrRadix), (unsignedOrRadix = false));
         }
         else {
             unsigned = !!unsignedOrRadix;
@@ -1780,15 +1825,6 @@ class Long extends BSONValue {
         return `new Long(${longVal}${unsignedVal})`;
     }
 }
-Long.TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
-Long.MAX_UNSIGNED_VALUE = Long.fromBits(0xffffffff | 0, 0xffffffff | 0, true);
-Long.ZERO = Long.fromInt(0);
-Long.UZERO = Long.fromInt(0, true);
-Long.ONE = Long.fromInt(1);
-Long.UONE = Long.fromInt(1, true);
-Long.NEG_ONE = Long.fromInt(-1);
-Long.MAX_VALUE = Long.fromBits(0xffffffff | 0, 0x7fffffff | 0, false);
-Long.MIN_VALUE = Long.fromBits(0, 0x80000000 | 0, false);
 
 const PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
 const PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
@@ -1869,6 +1905,7 @@ class Decimal128 extends BSONValue {
     get _bsontype() {
         return 'Decimal128';
     }
+    bytes;
     constructor(bytes) {
         super();
         if (typeof bytes === 'string') {
@@ -2344,6 +2381,7 @@ class Double extends BSONValue {
     get _bsontype() {
         return 'Double';
     }
+    value;
     constructor(value) {
         super();
         if (value instanceof Number) {
@@ -2407,6 +2445,7 @@ class Int32 extends BSONValue {
     get _bsontype() {
         return 'Int32';
     }
+    value;
     constructor(value) {
         super();
         if (value instanceof Number) {
@@ -2485,11 +2524,14 @@ class MinKey extends BSONValue {
 }
 
 let PROCESS_UNIQUE = null;
-const __idCache = new WeakMap();
 class ObjectId extends BSONValue {
     get _bsontype() {
         return 'ObjectId';
     }
+    static index = Math.floor(Math.random() * 0xffffff);
+    static cacheHexString = false;
+    buffer;
+    #cachedHexString = null;
     constructor(inputId) {
         super();
         let workingId;
@@ -2507,8 +2549,8 @@ class ObjectId extends BSONValue {
         else {
             workingId = inputId;
         }
-        if (workingId == null || typeof workingId === 'number') {
-            this.buffer = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
+        if (workingId == null) {
+            this.buffer = ObjectId.generate();
         }
         else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
             this.buffer = ByteUtils.toLocalBufferType(workingId);
@@ -2517,7 +2559,7 @@ class ObjectId extends BSONValue {
             if (ObjectId.validateHexString(workingId)) {
                 this.buffer = ByteUtils.fromHex(workingId);
                 if (ObjectId.cacheHexString) {
-                    __idCache.set(this, workingId);
+                    this.#cachedHexString = workingId;
                 }
             }
             else {
@@ -2534,7 +2576,7 @@ class ObjectId extends BSONValue {
     set id(value) {
         this.buffer = value;
         if (ObjectId.cacheHexString) {
-            __idCache.set(this, ByteUtils.toHex(value));
+            this.#cachedHexString = ByteUtils.toHex(value);
         }
     }
     static validateHexString(string) {
@@ -2552,14 +2594,11 @@ class ObjectId extends BSONValue {
         return true;
     }
     toHexString() {
-        if (ObjectId.cacheHexString) {
-            const __id = __idCache.get(this);
-            if (__id)
-                return __id;
-        }
+        if (this.#cachedHexString)
+            return this.#cachedHexString.toLowerCase();
         const hexString = ByteUtils.toHex(this.id);
         if (ObjectId.cacheHexString) {
-            __idCache.set(this, hexString);
+            this.#cachedHexString = hexString;
         }
         return hexString;
     }
@@ -2684,14 +2723,13 @@ class ObjectId extends BSONValue {
         return new ObjectId(doc.$oid);
     }
     isCached() {
-        return ObjectId.cacheHexString && __idCache.has(this);
+        return ObjectId.cacheHexString && this.#cachedHexString != null;
     }
     inspect(depth, options, inspect) {
         inspect ??= defaultInspect;
         return `new ObjectId(${inspect(this.toHexString(), options)})`;
     }
 }
-ObjectId.index = Math.floor(Math.random() * 0xffffff);
 
 function internalCalculateObjectSize(object, serializeFunctions, ignoreUndefined) {
     let totalLength = 4 + 1;
@@ -2860,6 +2898,8 @@ class BSONRegExp extends BSONValue {
     get _bsontype() {
         return 'BSONRegExp';
     }
+    pattern;
+    options;
     constructor(pattern, options) {
         super();
         this.pattern = pattern;
@@ -2920,6 +2960,7 @@ class BSONSymbol extends BSONValue {
     get _bsontype() {
         return 'BSONSymbol';
     }
+    value;
     constructor(value) {
         super();
         this.value = value;
@@ -2950,6 +2991,10 @@ class Timestamp extends LongWithoutOverridesClass {
     get _bsontype() {
         return 'Timestamp';
     }
+    get [bsonType]() {
+        return 'Timestamp';
+    }
+    static MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
     get i() {
         return this.low >>> 0;
     }
@@ -3029,7 +3074,6 @@ class Timestamp extends LongWithoutOverridesClass {
         return `new Timestamp({ t: ${t}, i: ${i} })`;
     }
 }
-Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 
 const JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX);
 const JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN);
@@ -4377,6 +4421,29 @@ EJSON.serialize = EJSONserialize;
 EJSON.deserialize = EJSONdeserialize;
 Object.freeze(EJSON);
 
+const BSONElementType = {
+    double: 1,
+    string: 2,
+    object: 3,
+    array: 4,
+    binData: 5,
+    undefined: 6,
+    objectId: 7,
+    bool: 8,
+    date: 9,
+    null: 10,
+    regex: 11,
+    dbPointer: 12,
+    javascript: 13,
+    symbol: 14,
+    javascriptWithScope: 15,
+    int: 16,
+    timestamp: 17,
+    long: 18,
+    decimal: 19,
+    minKey: 255,
+    maxKey: 127
+};
 function getSize(source, offset) {
     try {
         return NumberUtils.getNonnegativeInt32LE(source, offset);
@@ -4421,48 +4488,48 @@ function parseToElements(bytes, startOffset = 0) {
         const nameLength = findNull(bytes, offset) - nameOffset;
         offset += nameLength + 1;
         let length;
-        if (type === 1 ||
-            type === 18 ||
-            type === 9 ||
-            type === 17) {
+        if (type === BSONElementType.double ||
+            type === BSONElementType.long ||
+            type === BSONElementType.date ||
+            type === BSONElementType.timestamp) {
             length = 8;
         }
-        else if (type === 16) {
+        else if (type === BSONElementType.int) {
             length = 4;
         }
-        else if (type === 7) {
+        else if (type === BSONElementType.objectId) {
             length = 12;
         }
-        else if (type === 19) {
+        else if (type === BSONElementType.decimal) {
             length = 16;
         }
-        else if (type === 8) {
+        else if (type === BSONElementType.bool) {
             length = 1;
         }
-        else if (type === 10 ||
-            type === 6 ||
-            type === 127 ||
-            type === 255) {
+        else if (type === BSONElementType.null ||
+            type === BSONElementType.undefined ||
+            type === BSONElementType.maxKey ||
+            type === BSONElementType.minKey) {
             length = 0;
         }
-        else if (type === 11) {
+        else if (type === BSONElementType.regex) {
             length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset;
         }
-        else if (type === 3 ||
-            type === 4 ||
-            type === 15) {
+        else if (type === BSONElementType.object ||
+            type === BSONElementType.array ||
+            type === BSONElementType.javascriptWithScope) {
             length = getSize(bytes, offset);
         }
-        else if (type === 2 ||
-            type === 5 ||
-            type === 12 ||
-            type === 13 ||
-            type === 14) {
+        else if (type === BSONElementType.string ||
+            type === BSONElementType.binData ||
+            type === BSONElementType.dbPointer ||
+            type === BSONElementType.javascript ||
+            type === BSONElementType.symbol) {
             length = getSize(bytes, offset) + 4;
-            if (type === 5) {
+            if (type === BSONElementType.binData) {
                 length += 1;
             }
-            if (type === 12) {
+            if (type === BSONElementType.dbPointer) {
                 length += 12;
             }
         }
@@ -4558,6 +4625,7 @@ MinKey: MinKey,
 ObjectId: ObjectId,
 Timestamp: Timestamp,
 UUID: UUID,
+bsonType: bsonType,
 calculateObjectSize: calculateObjectSize,
 deserialize: deserialize,
 deserializeStream: deserializeStream,
@@ -4589,6 +4657,7 @@ exports.MinKey = MinKey;
 exports.ObjectId = ObjectId;
 exports.Timestamp = Timestamp;
 exports.UUID = UUID;
+exports.bsonType = bsonType;
 exports.calculateObjectSize = calculateObjectSize;
 exports.deserialize = deserialize;
 exports.deserializeStream = deserializeStream;