bson 5.2.0 → 5.3.0

package/lib/bson.bundle.js

@@ -1,6 +1,22 @@
 var BSON = (function (exports) {
 '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;
@@ -283,44 +299,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;
@@ -482,7 +460,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)}`);
@@ -509,47 +487,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')
@@ -588,27 +564,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();
     }
@@ -616,6 +597,7 @@ class UUID extends Binary {
         return `new UUID("${this.toHexString()}")`;
     }
 }
+UUID.cacheHexString = false;
 
 class Code extends BSONValue {
     get _bsontype() {
@@ -2792,7 +2774,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();
                     }
                 }
@@ -2818,11 +2800,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;
@@ -4054,32 +4036,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;