bson 5.2.0 → 5.4.0

package/lib/bson.cjs

@@ -1,5 +1,21 @@
 'use strict';
 
+function isAnyArrayBuffer(value) {
+    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
+}
+function isUint8Array(value) {
+    return Object.prototype.toString.call(value) === '[object Uint8Array]';
+}
+function isRegExp(d) {
+    return Object.prototype.toString.call(d) === '[object RegExp]';
+}
+function isMap(d) {
+    return Object.prototype.toString.call(d) === '[object Map]';
+}
+function isDate(d) {
+    return Object.prototype.toString.call(d) === '[object Date]';
+}
+
 const BSON_MAJOR_VERSION = 5;
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
@@ -149,8 +165,8 @@ const nodeJsByteUtils = {
     fromUTF8(text) {
         return Buffer.from(text, 'utf8');
     },
-    toUTF8(buffer) {
-        return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8');
+    toUTF8(buffer, start, end) {
+        return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
     },
     utf8ByteLength(input) {
         return Buffer.byteLength(input, 'utf8');
@@ -260,8 +276,8 @@ const webByteUtils = {
     fromUTF8(text) {
         return new TextEncoder().encode(text);
     },
-    toUTF8(uint8array) {
-        return new TextDecoder('utf8', { fatal: false }).decode(uint8array);
+    toUTF8(uint8array, start, end) {
+        return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
     },
     utf8ByteLength(input) {
         return webByteUtils.fromUTF8(input).byteLength;
@@ -282,44 +298,6 @@ class BSONDataView extends DataView {
     }
 }
 
-const VALIDATION_REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|[0-9a-f]{12}4[0-9a-f]{3}[89ab][0-9a-f]{15})$/i;
-const uuidValidateString = (str) => typeof str === 'string' && VALIDATION_REGEX.test(str);
-const uuidHexStringToBuffer = (hexString) => {
-    if (!uuidValidateString(hexString)) {
-        throw new BSONError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
-    }
-    const sanitizedHexString = hexString.replace(/-/g, '');
-    return ByteUtils.fromHex(sanitizedHexString);
-};
-function bufferToUuidHexString(buffer, includeDashes = true) {
-    if (includeDashes) {
-        return [
-            ByteUtils.toHex(buffer.subarray(0, 4)),
-            ByteUtils.toHex(buffer.subarray(4, 6)),
-            ByteUtils.toHex(buffer.subarray(6, 8)),
-            ByteUtils.toHex(buffer.subarray(8, 10)),
-            ByteUtils.toHex(buffer.subarray(10, 16))
-        ].join('-');
-    }
-    return ByteUtils.toHex(buffer);
-}
-
-function isAnyArrayBuffer(value) {
-    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
-}
-function isUint8Array(value) {
-    return Object.prototype.toString.call(value) === '[object Uint8Array]';
-}
-function isRegExp(d) {
-    return Object.prototype.toString.call(d) === '[object RegExp]';
-}
-function isMap(d) {
-    return Object.prototype.toString.call(d) === '[object Map]';
-}
-function isDate(d) {
-    return Object.prototype.toString.call(d) === '[object Date]';
-}
-
 class BSONValue {
     get [Symbol.for('@@mdb.bson.version')]() {
         return BSON_MAJOR_VERSION;
@@ -431,8 +409,8 @@ class Binary extends BSONValue {
         if (encoding === 'base64')
             return ByteUtils.toBase64(this.buffer);
         if (encoding === 'utf8' || encoding === 'utf-8')
-            return ByteUtils.toUTF8(this.buffer);
-        return ByteUtils.toUTF8(this.buffer);
+            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
+        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
     }
     toExtendedJSON(options) {
         options = options || {};
@@ -481,7 +459,7 @@ class Binary extends BSONValue {
         }
         else if ('$uuid' in doc) {
             type = 4;
-            data = uuidHexStringToBuffer(doc.$uuid);
+            data = UUID.bytesFromString(doc.$uuid);
         }
         if (!data) {
             throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
@@ -508,47 +486,45 @@ Binary.SUBTYPE_ENCRYPTED = 6;
 Binary.SUBTYPE_COLUMN = 7;
 Binary.SUBTYPE_USER_DEFINED = 128;
 const UUID_BYTE_LENGTH = 16;
+const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
+const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
 class UUID extends Binary {
     constructor(input) {
         let bytes;
-        let hexStr;
         if (input == null) {
             bytes = UUID.generate();
         }
         else if (input instanceof UUID) {
             bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));
-            hexStr = input.__id;
         }
         else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
             bytes = ByteUtils.toLocalBufferType(input);
         }
         else if (typeof input === 'string') {
-            bytes = uuidHexStringToBuffer(input);
+            bytes = UUID.bytesFromString(input);
         }
         else {
             throw new BSONError('Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).');
         }
         super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);
-        this.__id = hexStr;
     }
     get id() {
         return this.buffer;
     }
     set id(value) {
         this.buffer = value;
-        if (UUID.cacheHexString) {
-            this.__id = bufferToUuidHexString(value);
-        }
     }
     toHexString(includeDashes = true) {
-        if (UUID.cacheHexString && this.__id) {
-            return this.__id;
-        }
-        const uuidHexString = bufferToUuidHexString(this.id, includeDashes);
-        if (UUID.cacheHexString) {
-            this.__id = uuidHexString;
+        if (includeDashes) {
+            return [
+                ByteUtils.toHex(this.buffer.subarray(0, 4)),
+                ByteUtils.toHex(this.buffer.subarray(4, 6)),
+                ByteUtils.toHex(this.buffer.subarray(6, 8)),
+                ByteUtils.toHex(this.buffer.subarray(8, 10)),
+                ByteUtils.toHex(this.buffer.subarray(10, 16))
+            ].join('-');
         }
-        return uuidHexString;
+        return ByteUtils.toHex(this.buffer);
     }
     toString(encoding) {
         if (encoding === 'hex')
@@ -587,27 +563,32 @@ class UUID extends Binary {
         if (!input) {
             return false;
         }
-        if (input instanceof UUID) {
-            return true;
-        }
         if (typeof input === 'string') {
-            return uuidValidateString(input);
+            return UUID.isValidUUIDString(input);
         }
         if (isUint8Array(input)) {
-            if (input.byteLength !== UUID_BYTE_LENGTH) {
-                return false;
-            }
-            return (input[6] & 0xf0) === 0x40 && (input[8] & 0x80) === 0x80;
+            return input.byteLength === UUID_BYTE_LENGTH;
         }
-        return false;
+        return (input._bsontype === 'Binary' &&
+            input.sub_type === this.SUBTYPE_UUID &&
+            input.buffer.byteLength === 16);
     }
     static createFromHexString(hexString) {
-        const buffer = uuidHexStringToBuffer(hexString);
+        const buffer = UUID.bytesFromString(hexString);
         return new UUID(buffer);
     }
     static createFromBase64(base64) {
         return new UUID(ByteUtils.fromBase64(base64));
     }
+    static bytesFromString(representation) {
+        if (!UUID.isValidUUIDString(representation)) {
+            throw new BSONError('UUID string representation must be 32 hex digits or canonical hyphenated representation');
+        }
+        return ByteUtils.fromHex(representation.replace(/-/g, ''));
+    }
+    static isValidUUIDString(representation) {
+        return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);
+    }
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
     }
@@ -615,6 +596,7 @@ class UUID extends Binary {
         return `new UUID("${this.toHexString()}")`;
     }
 }
+UUID.cacheHexString = false;
 
 class Code extends BSONValue {
     get _bsontype() {
@@ -2434,19 +2416,21 @@ class Timestamp extends LongWithoutOverridesClass {
             if (typeof low.i !== 'number' && (typeof low.i !== 'object' || low.i._bsontype !== 'Int32')) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide i as a number');
             }
-            if (low.t < 0) {
+            const t = Number(low.t);
+            const i = Number(low.i);
+            if (t < 0 || Number.isNaN(t)) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide a positive t');
             }
-            if (low.i < 0) {
+            if (i < 0 || Number.isNaN(i)) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');
             }
-            if (low.t > 4294967295) {
+            if (t > 4294967295) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide t equal or less than uint32 max');
             }
-            if (low.i > 4294967295) {
+            if (i > 4294967295) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide i equal or less than uint32 max');
             }
-            super(low.i.valueOf(), low.t.valueOf(), true);
+            super(i, t, true);
         }
         else {
             throw new BSONError('A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }');
@@ -2618,7 +2602,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
         if (i >= buffer.byteLength)
             throw new BSONError('Bad BSON Document: illegal CString');
-        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer.subarray(index, i));
+        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i);
         let shouldValidateKey = true;
         if (globalUTFValidation || utf8KeysSet.has(name)) {
             shouldValidateKey = validationSetting;
@@ -2791,7 +2775,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
+                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
                         value = value.toUUID();
                     }
                 }
@@ -2817,11 +2801,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 if (promoteBuffers && promoteValues) {
                     value = _buffer;
                 }
-                else if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType).toUUID();
-                }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
+                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
+                        value = value.toUUID();
+                    }
                 }
             }
             index = index + binarySize;
@@ -2833,7 +2817,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const source = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const source = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2841,7 +2825,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const regExpOptions = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             const optionsArray = new Array(regExpOptions.length);
             for (i = 0; i < regExpOptions.length; i++) {
@@ -2866,7 +2850,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const source = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const source = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2874,7 +2858,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const regExpOptions = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             value = new BSONRegExp(source, regExpOptions);
         }
@@ -2971,7 +2955,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                     throw new BSONError('Invalid UTF-8 string in BSON document');
                 }
             }
-            const namespace = ByteUtils.toUTF8(buffer.subarray(index, index + stringSize - 1));
+            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);
             index = index + stringSize;
             const oidBuffer = ByteUtils.allocate(12);
             oidBuffer.set(buffer.subarray(index, index + 12), 0);
@@ -3011,7 +2995,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
     return object;
 }
 function getValidatedString(buffer, start, end, shouldValidateUtf8) {
-    const value = ByteUtils.toUTF8(buffer.subarray(start, end));
+    const value = ByteUtils.toUTF8(buffer, start, end);
     if (shouldValidateUtf8) {
         for (let i = 0; i < value.length; i++) {
             if (value.charCodeAt(i) === 0xfffd) {
@@ -4053,32 +4037,32 @@ function deserializeStream(data, startIndex, numberOfDocuments, documents, docSt
 
 var bson = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Code: Code,
+    BSONError: BSONError,
+    BSONRegExp: BSONRegExp,
+    BSONRuntimeError: BSONRuntimeError,
     BSONSymbol: BSONSymbol,
-    DBRef: DBRef,
+    BSONType: BSONType,
+    BSONValue: BSONValue,
+    BSONVersionError: BSONVersionError,
     Binary: Binary,
-    ObjectId: ObjectId,
-    UUID: UUID,
-    Long: Long,
-    Timestamp: Timestamp,
+    Code: Code,
+    DBRef: DBRef,
+    Decimal128: Decimal128,
     Double: Double,
+    EJSON: EJSON,
     Int32: Int32,
-    MinKey: MinKey,
+    Long: Long,
     MaxKey: MaxKey,
-    BSONRegExp: BSONRegExp,
-    Decimal128: Decimal128,
-    setInternalBufferSize: setInternalBufferSize,
-    serialize: serialize,
-    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
-    deserialize: deserialize,
+    MinKey: MinKey,
+    ObjectId: ObjectId,
+    Timestamp: Timestamp,
+    UUID: UUID,
     calculateObjectSize: calculateObjectSize,
+    deserialize: deserialize,
     deserializeStream: deserializeStream,
-    BSONValue: BSONValue,
-    BSONError: BSONError,
-    BSONVersionError: BSONVersionError,
-    BSONRuntimeError: BSONRuntimeError,
-    BSONType: BSONType,
-    EJSON: EJSON
+    serialize: serialize,
+    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
+    setInternalBufferSize: setInternalBufferSize
 });
 
 exports.BSON = bson;