bson 6.10.3 → 7.0.0-alpha

package/lib/bson.cjs

@@ -142,6 +142,7 @@ class BSONOffsetError extends BSONError {
     get name() {
         return 'BSONOffsetError';
     }
+    offset;
     constructor(message, offset, options) {
         super(`${message}. offset: ${offset}`, options);
         this.offset = offset;
@@ -218,11 +219,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;
     }
 })();
@@ -441,7 +446,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;
     }
@@ -492,7 +501,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) => {
@@ -538,7 +547,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;
@@ -547,7 +556,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;
@@ -588,6 +597,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) &&
@@ -750,6 +780,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() {
@@ -759,6 +790,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);
@@ -771,6 +803,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() {
@@ -780,6 +813,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);
@@ -798,7 +832,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);
@@ -808,14 +844,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;
@@ -837,24 +877,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;
@@ -865,6 +887,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');
     }
@@ -986,6 +1013,8 @@ class Code extends BSONValue {
     get _bsontype() {
         return 'Code';
     }
+    code;
+    scope;
     constructor(code, scope) {
         super();
         this.code = code.toString();
@@ -1031,6 +1060,10 @@ class DBRef extends BSONValue {
     get _bsontype() {
         return 'DBRef';
     }
+    collection;
+    oid;
+    db;
+    fields;
     constructor(collection, oid, db, fields) {
         super();
         const parts = collection.split('.');
@@ -1140,6 +1173,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);
@@ -1153,6 +1189,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);
     }
@@ -1193,7 +1238,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;
@@ -1203,8 +1248,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) {
@@ -1237,7 +1282,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;
@@ -1259,7 +1304,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;
@@ -1779,15 +1824,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;
@@ -1868,6 +1904,7 @@ class Decimal128 extends BSONValue {
     get _bsontype() {
         return 'Decimal128';
     }
+    bytes;
     constructor(bytes) {
         super();
         if (typeof bytes === 'string') {
@@ -2343,6 +2380,7 @@ class Double extends BSONValue {
     get _bsontype() {
         return 'Double';
     }
+    value;
     constructor(value) {
         super();
         if (value instanceof Number) {
@@ -2406,6 +2444,7 @@ class Int32 extends BSONValue {
     get _bsontype() {
         return 'Int32';
     }
+    value;
     constructor(value) {
         super();
         if (value instanceof Number) {
@@ -2484,11 +2523,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;
@@ -2506,8 +2548,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);
@@ -2516,7 +2558,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 {
@@ -2533,7 +2575,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) {
@@ -2551,14 +2593,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;
     }
@@ -2683,14 +2722,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;
@@ -2859,6 +2897,8 @@ class BSONRegExp extends BSONValue {
     get _bsontype() {
         return 'BSONRegExp';
     }
+    pattern;
+    options;
     constructor(pattern, options) {
         super();
         this.pattern = pattern;
@@ -2919,6 +2959,7 @@ class BSONSymbol extends BSONValue {
     get _bsontype() {
         return 'BSONSymbol';
     }
+    value;
     constructor(value) {
         super();
         this.value = value;
@@ -2949,6 +2990,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;
     }
@@ -3028,7 +3073,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);
@@ -4376,6 +4420,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);
@@ -4420,48 +4487,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;
             }
         }
@@ -4557,6 +4624,7 @@ var bson = /*#__PURE__*/Object.freeze({
     ObjectId: ObjectId,
     Timestamp: Timestamp,
     UUID: UUID,
+    bsonType: bsonType,
     calculateObjectSize: calculateObjectSize,
     deserialize: deserialize,
     deserializeStream: deserializeStream,
@@ -4588,6 +4656,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;