bson 4.6.5 → 4.7.1

package/dist/bson.bundle.js

@@ -2268,174 +2268,84 @@ var BSON = (function (exports) {
 	        : buffer.toString('hex');
 	};
 
-	var BYTE_LENGTH = 16;
-	var kId$1 = Symbol('id');
+	/** @internal */
+	var BSON_INT32_MAX$1 = 0x7fffffff;
+	/** @internal */
+	var BSON_INT32_MIN$1 = -0x80000000;
+	/** @internal */
+	var BSON_INT64_MAX$1 = Math.pow(2, 63) - 1;
+	/** @internal */
+	var BSON_INT64_MIN$1 = -Math.pow(2, 63);
 	/**
-	 * A class representation of the BSON UUID type.
-	 * @public
+	 * Any integer up to 2^53 can be precisely represented by a double.
+	 * @internal
 	 */
-	var UUID = /** @class */ (function () {
-	    /**
-	     * Create an UUID type
-	     *
-	     * @param input - Can be a 32 or 36 character hex string (dashes excluded/included) or a 16 byte binary Buffer.
-	     */
-	    function UUID(input) {
-	        if (typeof input === 'undefined') {
-	            // The most common use case (blank id, new UUID() instance)
-	            this.id = UUID.generate();
-	        }
-	        else if (input instanceof UUID) {
-	            this[kId$1] = buffer_1.from(input.id);
-	            this.__id = input.__id;
-	        }
-	        else if (ArrayBuffer.isView(input) && input.byteLength === BYTE_LENGTH) {
-	            this.id = ensureBuffer(input);
-	        }
-	        else if (typeof input === 'string') {
-	            this.id = uuidHexStringToBuffer(input);
-	        }
-	        else {
-	            throw new BSONTypeError('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).');
-	        }
-	    }
-	    Object.defineProperty(UUID.prototype, "id", {
-	        /**
-	         * The UUID bytes
-	         * @readonly
-	         */
-	        get: function () {
-	            return this[kId$1];
-	        },
-	        set: function (value) {
-	            this[kId$1] = value;
-	            if (UUID.cacheHexString) {
-	                this.__id = bufferToUuidHexString(value);
-	            }
-	        },
-	        enumerable: false,
-	        configurable: true
-	    });
-	    /**
-	     * Generate a 16 byte uuid v4 buffer used in UUIDs
-	     */
-	    /**
-	     * Returns the UUID id as a 32 or 36 character hex string representation, excluding/including dashes (defaults to 36 character dash separated)
-	     * @param includeDashes - should the string exclude dash-separators.
-	     * */
-	    UUID.prototype.toHexString = function (includeDashes) {
-	        if (includeDashes === void 0) { includeDashes = true; }
-	        if (UUID.cacheHexString && this.__id) {
-	            return this.__id;
-	        }
-	        var uuidHexString = bufferToUuidHexString(this.id, includeDashes);
-	        if (UUID.cacheHexString) {
-	            this.__id = uuidHexString;
-	        }
-	        return uuidHexString;
-	    };
-	    /**
-	     * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.
-	     */
-	    UUID.prototype.toString = function (encoding) {
-	        return encoding ? this.id.toString(encoding) : this.toHexString();
-	    };
-	    /**
-	     * Converts the id into its JSON string representation.
-	     * A 36 character (dashes included) hex string in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-	     */
-	    UUID.prototype.toJSON = function () {
-	        return this.toHexString();
-	    };
-	    /**
-	     * Compares the equality of this UUID with `otherID`.
-	     *
-	     * @param otherId - UUID instance to compare against.
-	     */
-	    UUID.prototype.equals = function (otherId) {
-	        if (!otherId) {
-	            return false;
-	        }
-	        if (otherId instanceof UUID) {
-	            return otherId.id.equals(this.id);
-	        }
-	        try {
-	            return new UUID(otherId).id.equals(this.id);
-	        }
-	        catch (_a) {
-	            return false;
-	        }
-	    };
-	    /**
-	     * Creates a Binary instance from the current UUID.
-	     */
-	    UUID.prototype.toBinary = function () {
-	        return new Binary(this.id, Binary.SUBTYPE_UUID);
-	    };
-	    /**
-	     * Generates a populated buffer containing a v4 uuid
-	     */
-	    UUID.generate = function () {
-	        var bytes = randomBytes(BYTE_LENGTH);
-	        // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-	        // Kindly borrowed from https://github.com/uuidjs/uuid/blob/master/src/v4.js
-	        bytes[6] = (bytes[6] & 0x0f) | 0x40;
-	        bytes[8] = (bytes[8] & 0x3f) | 0x80;
-	        return buffer_1.from(bytes);
-	    };
-	    /**
-	     * Checks if a value is a valid bson UUID
-	     * @param input - UUID, string or Buffer to validate.
-	     */
-	    UUID.isValid = function (input) {
-	        if (!input) {
-	            return false;
-	        }
-	        if (input instanceof UUID) {
-	            return true;
-	        }
-	        if (typeof input === 'string') {
-	            return uuidValidateString(input);
-	        }
-	        if (isUint8Array(input)) {
-	            // check for length & uuid version (https://tools.ietf.org/html/rfc4122#section-4.1.3)
-	            if (input.length !== BYTE_LENGTH) {
-	                return false;
-	            }
-	            try {
-	                // get this byte as hex:             xxxxxxxx-xxxx-XXxx-xxxx-xxxxxxxxxxxx
-	                // check first part as uuid version: xxxxxxxx-xxxx-Xxxx-xxxx-xxxxxxxxxxxx
-	                return parseInt(input[6].toString(16)[0], 10) === Binary.SUBTYPE_UUID;
-	            }
-	            catch (_a) {
-	                return false;
-	            }
-	        }
-	        return false;
-	    };
-	    /**
-	     * Creates an UUID from a hex string representation of an UUID.
-	     * @param hexString - 32 or 36 character hex string (dashes excluded/included).
-	     */
-	    UUID.createFromHexString = function (hexString) {
-	        var buffer = uuidHexStringToBuffer(hexString);
-	        return new UUID(buffer);
-	    };
-	    /**
-	     * Converts to a string representation of this Id.
-	     *
-	     * @returns return the 36 character hex string representation.
-	     * @internal
-	     */
-	    UUID.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
-	        return this.inspect();
-	    };
-	    UUID.prototype.inspect = function () {
-	        return "new UUID(\"".concat(this.toHexString(), "\")");
-	    };
-	    return UUID;
-	}());
-	Object.defineProperty(UUID.prototype, '_bsontype', { value: 'UUID' });
+	var JS_INT_MAX = Math.pow(2, 53);
+	/**
+	 * Any integer down to -2^53 can be precisely represented by a double.
+	 * @internal
+	 */
+	var JS_INT_MIN = -Math.pow(2, 53);
+	/** Number BSON Type @internal */
+	var BSON_DATA_NUMBER = 1;
+	/** String BSON Type @internal */
+	var BSON_DATA_STRING = 2;
+	/** Object BSON Type @internal */
+	var BSON_DATA_OBJECT = 3;
+	/** Array BSON Type @internal */
+	var BSON_DATA_ARRAY = 4;
+	/** Binary BSON Type @internal */
+	var BSON_DATA_BINARY = 5;
+	/** Binary BSON Type @internal */
+	var BSON_DATA_UNDEFINED = 6;
+	/** ObjectId BSON Type @internal */
+	var BSON_DATA_OID = 7;
+	/** Boolean BSON Type @internal */
+	var BSON_DATA_BOOLEAN = 8;
+	/** Date BSON Type @internal */
+	var BSON_DATA_DATE = 9;
+	/** null BSON Type @internal */
+	var BSON_DATA_NULL = 10;
+	/** RegExp BSON Type @internal */
+	var BSON_DATA_REGEXP = 11;
+	/** Code BSON Type @internal */
+	var BSON_DATA_DBPOINTER = 12;
+	/** Code BSON Type @internal */
+	var BSON_DATA_CODE = 13;
+	/** Symbol BSON Type @internal */
+	var BSON_DATA_SYMBOL = 14;
+	/** Code with Scope BSON Type @internal */
+	var BSON_DATA_CODE_W_SCOPE = 15;
+	/** 32 bit Integer BSON Type @internal */
+	var BSON_DATA_INT = 16;
+	/** Timestamp BSON Type @internal */
+	var BSON_DATA_TIMESTAMP = 17;
+	/** Long BSON Type @internal */
+	var BSON_DATA_LONG = 18;
+	/** Decimal128 BSON Type @internal */
+	var BSON_DATA_DECIMAL128 = 19;
+	/** MinKey BSON Type @internal */
+	var BSON_DATA_MIN_KEY = 0xff;
+	/** MaxKey BSON Type @internal */
+	var BSON_DATA_MAX_KEY = 0x7f;
+	/** Binary Default Type @internal */
+	var BSON_BINARY_SUBTYPE_DEFAULT = 0;
+	/** Binary Function Type @internal */
+	var BSON_BINARY_SUBTYPE_FUNCTION = 1;
+	/** Binary Byte Array Type @internal */
+	var BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
+	/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */
+	var BSON_BINARY_SUBTYPE_UUID = 3;
+	/** Binary UUID Type @internal */
+	var BSON_BINARY_SUBTYPE_UUID_NEW = 4;
+	/** Binary MD5 Type @internal */
+	var BSON_BINARY_SUBTYPE_MD5 = 5;
+	/** Encrypted BSON type @internal */
+	var BSON_BINARY_SUBTYPE_ENCRYPTED = 6;
+	/** Column BSON type @internal */
+	var BSON_BINARY_SUBTYPE_COLUMN = 7;
+	/** Binary User Defined Type @internal */
+	var BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
 
 	/**
 	 * A class representation of the BSON Binary type.
@@ -2636,7 +2546,7 @@ var BSON = (function (exports) {
 	        if (!data) {
 	            throw new BSONTypeError("Unexpected Binary Extended JSON format ".concat(JSON.stringify(doc)));
 	        }
-	        return new Binary(data, type);
+	        return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);
 	    };
 	    /** @internal */
 	    Binary.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
@@ -2674,6 +2584,168 @@ var BSON = (function (exports) {
 	    return Binary;
 	}());
 	Object.defineProperty(Binary.prototype, '_bsontype', { value: 'Binary' });
+	var UUID_BYTE_LENGTH = 16;
+	/**
+	 * A class representation of the BSON UUID type.
+	 * @public
+	 */
+	var UUID = /** @class */ (function (_super) {
+	    __extends(UUID, _super);
+	    /**
+	     * Create an UUID type
+	     *
+	     * @param input - Can be a 32 or 36 character hex string (dashes excluded/included) or a 16 byte binary Buffer.
+	     */
+	    function UUID(input) {
+	        var _this = this;
+	        var bytes;
+	        var hexStr;
+	        if (input == null) {
+	            bytes = UUID.generate();
+	        }
+	        else if (input instanceof UUID) {
+	            bytes = buffer_1.from(input.buffer);
+	            hexStr = input.__id;
+	        }
+	        else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
+	            bytes = ensureBuffer(input);
+	        }
+	        else if (typeof input === 'string') {
+	            bytes = uuidHexStringToBuffer(input);
+	        }
+	        else {
+	            throw new BSONTypeError('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).');
+	        }
+	        _this = _super.call(this, bytes, BSON_BINARY_SUBTYPE_UUID_NEW) || this;
+	        _this.__id = hexStr;
+	        return _this;
+	    }
+	    Object.defineProperty(UUID.prototype, "id", {
+	        /**
+	         * The UUID bytes
+	         * @readonly
+	         */
+	        get: function () {
+	            return this.buffer;
+	        },
+	        set: function (value) {
+	            this.buffer = value;
+	            if (UUID.cacheHexString) {
+	                this.__id = bufferToUuidHexString(value);
+	            }
+	        },
+	        enumerable: false,
+	        configurable: true
+	    });
+	    /**
+	     * Returns the UUID id as a 32 or 36 character hex string representation, excluding/including dashes (defaults to 36 character dash separated)
+	     * @param includeDashes - should the string exclude dash-separators.
+	     * */
+	    UUID.prototype.toHexString = function (includeDashes) {
+	        if (includeDashes === void 0) { includeDashes = true; }
+	        if (UUID.cacheHexString && this.__id) {
+	            return this.__id;
+	        }
+	        var uuidHexString = bufferToUuidHexString(this.id, includeDashes);
+	        if (UUID.cacheHexString) {
+	            this.__id = uuidHexString;
+	        }
+	        return uuidHexString;
+	    };
+	    /**
+	     * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.
+	     */
+	    UUID.prototype.toString = function (encoding) {
+	        return encoding ? this.id.toString(encoding) : this.toHexString();
+	    };
+	    /**
+	     * Converts the id into its JSON string representation.
+	     * A 36 character (dashes included) hex string in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+	     */
+	    UUID.prototype.toJSON = function () {
+	        return this.toHexString();
+	    };
+	    /**
+	     * Compares the equality of this UUID with `otherID`.
+	     *
+	     * @param otherId - UUID instance to compare against.
+	     */
+	    UUID.prototype.equals = function (otherId) {
+	        if (!otherId) {
+	            return false;
+	        }
+	        if (otherId instanceof UUID) {
+	            return otherId.id.equals(this.id);
+	        }
+	        try {
+	            return new UUID(otherId).id.equals(this.id);
+	        }
+	        catch (_a) {
+	            return false;
+	        }
+	    };
+	    /**
+	     * Creates a Binary instance from the current UUID.
+	     */
+	    UUID.prototype.toBinary = function () {
+	        return new Binary(this.id, Binary.SUBTYPE_UUID);
+	    };
+	    /**
+	     * Generates a populated buffer containing a v4 uuid
+	     */
+	    UUID.generate = function () {
+	        var bytes = randomBytes(UUID_BYTE_LENGTH);
+	        // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+	        // Kindly borrowed from https://github.com/uuidjs/uuid/blob/master/src/v4.js
+	        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+	        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+	        return buffer_1.from(bytes);
+	    };
+	    /**
+	     * Checks if a value is a valid bson UUID
+	     * @param input - UUID, string or Buffer to validate.
+	     */
+	    UUID.isValid = function (input) {
+	        if (!input) {
+	            return false;
+	        }
+	        if (input instanceof UUID) {
+	            return true;
+	        }
+	        if (typeof input === 'string') {
+	            return uuidValidateString(input);
+	        }
+	        if (isUint8Array(input)) {
+	            // check for length & uuid version (https://tools.ietf.org/html/rfc4122#section-4.1.3)
+	            if (input.length !== UUID_BYTE_LENGTH) {
+	                return false;
+	            }
+	            return (input[6] & 0xf0) === 0x40 && (input[8] & 0x80) === 0x80;
+	        }
+	        return false;
+	    };
+	    /**
+	     * Creates an UUID from a hex string representation of an UUID.
+	     * @param hexString - 32 or 36 character hex string (dashes excluded/included).
+	     */
+	    UUID.createFromHexString = function (hexString) {
+	        var buffer = uuidHexStringToBuffer(hexString);
+	        return new UUID(buffer);
+	    };
+	    /**
+	     * Converts to a string representation of this Id.
+	     *
+	     * @returns return the 36 character hex string representation.
+	     * @internal
+	     */
+	    UUID.prototype[Symbol.for('nodejs.util.inspect.custom')] = function () {
+	        return this.inspect();
+	    };
+	    UUID.prototype.inspect = function () {
+	        return "new UUID(\"".concat(this.toHexString(), "\")");
+	    };
+	    return UUID;
+	}(Binary));
 
 	/**
 	 * A class representation of the BSON Code type.
@@ -4402,22 +4474,17 @@ var BSON = (function (exports) {
 	        if (options && (options.legacy || (options.relaxed && isFinite(this.value)))) {
 	            return this.value;
 	        }
-	        // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user
-	        // explicitly provided `-0` then we need to ensure the sign makes it into the output
 	        if (Object.is(Math.sign(this.value), -0)) {
-	            return { $numberDouble: "-".concat(this.value.toFixed(1)) };
+	            // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user
+	            // explicitly provided `-0` then we need to ensure the sign makes it into the output
+	            return { $numberDouble: '-0.0' };
 	        }
-	        var $numberDouble;
 	        if (Number.isInteger(this.value)) {
-	            $numberDouble = this.value.toFixed(1);
-	            if ($numberDouble.length >= 13) {
-	                $numberDouble = this.value.toExponential(13).toUpperCase();
-	            }
+	            return { $numberDouble: "".concat(this.value, ".0") };
 	        }
 	        else {
-	            $numberDouble = this.value.toString();
+	            return { $numberDouble: "".concat(this.value) };
 	        }
-	        return { $numberDouble: $numberDouble };
 	    };
 	    /** @internal */
 	    Double.fromExtendedJSON = function (doc, options) {
@@ -5037,12 +5104,12 @@ var BSON = (function (exports) {
 	    return (isObjectLike(value) && Reflect.has(value, '_bsontype') && typeof value._bsontype === 'string');
 	}
 	// INT32 boundaries
-	var BSON_INT32_MAX$1 = 0x7fffffff;
-	var BSON_INT32_MIN$1 = -0x80000000;
+	var BSON_INT32_MAX = 0x7fffffff;
+	var BSON_INT32_MIN = -0x80000000;
 	// INT64 boundaries
 	// const BSON_INT64_MAX = 0x7fffffffffffffff; // TODO(NODE-4377): This number cannot be precisely represented in JS
-	var BSON_INT64_MAX$1 = 0x8000000000000000;
-	var BSON_INT64_MIN$1 = -0x8000000000000000;
+	var BSON_INT64_MAX = 0x8000000000000000;
+	var BSON_INT64_MIN = -0x8000000000000000;
 	// all the types where we don't need to do any special processing and can just pass the EJSON
 	//straight to type.fromExtendedJSON
 	var keysToCodecs = {
@@ -5070,9 +5137,9 @@ var BSON = (function (exports) {
 	        // if it's an integer, should interpret as smallest BSON integer
 	        // that can represent it exactly. (if out of range, interpret as double.)
 	        if (Math.floor(value) === value) {
-	            if (value >= BSON_INT32_MIN$1 && value <= BSON_INT32_MAX$1)
+	            if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX)
 	                return new Int32(value);
-	            if (value >= BSON_INT64_MIN$1 && value <= BSON_INT64_MAX$1)
+	            if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX)
 	                return Long.fromNumber(value);
 	        }
 	        // If the number is a non-integer or out of integer range, should interpret as BSON Double.
@@ -5196,7 +5263,7 @@ var BSON = (function (exports) {
 	    if (typeof value === 'number' && (!options.relaxed || !isFinite(value))) {
 	        // it's an integer
 	        if (Math.floor(value) === value) {
-	            var int32Range = value >= BSON_INT32_MIN$1 && value <= BSON_INT32_MAX$1, int64Range = value >= BSON_INT64_MIN$1 && value <= BSON_INT64_MAX$1;
+	            var int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX, int64Range = value >= BSON_INT64_MIN && value <= BSON_INT64_MAX;
 	            // interpret as being of the smallest BSON integer type that can represent the number exactly
 	            if (int32Range)
 	                return { $numberInt: value.toString() };
@@ -5521,85 +5588,6 @@ var BSON = (function (exports) {
 	    }());
 	}
 
-	/** @internal */
-	var BSON_INT32_MAX = 0x7fffffff;
-	/** @internal */
-	var BSON_INT32_MIN = -0x80000000;
-	/** @internal */
-	var BSON_INT64_MAX = Math.pow(2, 63) - 1;
-	/** @internal */
-	var BSON_INT64_MIN = -Math.pow(2, 63);
-	/**
-	 * Any integer up to 2^53 can be precisely represented by a double.
-	 * @internal
-	 */
-	var JS_INT_MAX = Math.pow(2, 53);
-	/**
-	 * Any integer down to -2^53 can be precisely represented by a double.
-	 * @internal
-	 */
-	var JS_INT_MIN = -Math.pow(2, 53);
-	/** Number BSON Type @internal */
-	var BSON_DATA_NUMBER = 1;
-	/** String BSON Type @internal */
-	var BSON_DATA_STRING = 2;
-	/** Object BSON Type @internal */
-	var BSON_DATA_OBJECT = 3;
-	/** Array BSON Type @internal */
-	var BSON_DATA_ARRAY = 4;
-	/** Binary BSON Type @internal */
-	var BSON_DATA_BINARY = 5;
-	/** Binary BSON Type @internal */
-	var BSON_DATA_UNDEFINED = 6;
-	/** ObjectId BSON Type @internal */
-	var BSON_DATA_OID = 7;
-	/** Boolean BSON Type @internal */
-	var BSON_DATA_BOOLEAN = 8;
-	/** Date BSON Type @internal */
-	var BSON_DATA_DATE = 9;
-	/** null BSON Type @internal */
-	var BSON_DATA_NULL = 10;
-	/** RegExp BSON Type @internal */
-	var BSON_DATA_REGEXP = 11;
-	/** Code BSON Type @internal */
-	var BSON_DATA_DBPOINTER = 12;
-	/** Code BSON Type @internal */
-	var BSON_DATA_CODE = 13;
-	/** Symbol BSON Type @internal */
-	var BSON_DATA_SYMBOL = 14;
-	/** Code with Scope BSON Type @internal */
-	var BSON_DATA_CODE_W_SCOPE = 15;
-	/** 32 bit Integer BSON Type @internal */
-	var BSON_DATA_INT = 16;
-	/** Timestamp BSON Type @internal */
-	var BSON_DATA_TIMESTAMP = 17;
-	/** Long BSON Type @internal */
-	var BSON_DATA_LONG = 18;
-	/** Decimal128 BSON Type @internal */
-	var BSON_DATA_DECIMAL128 = 19;
-	/** MinKey BSON Type @internal */
-	var BSON_DATA_MIN_KEY = 0xff;
-	/** MaxKey BSON Type @internal */
-	var BSON_DATA_MAX_KEY = 0x7f;
-	/** Binary Default Type @internal */
-	var BSON_BINARY_SUBTYPE_DEFAULT = 0;
-	/** Binary Function Type @internal */
-	var BSON_BINARY_SUBTYPE_FUNCTION = 1;
-	/** Binary Byte Array Type @internal */
-	var BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
-	/** Binary Deprecated UUID Type @deprecated Please use BSON_BINARY_SUBTYPE_UUID_NEW @internal */
-	var BSON_BINARY_SUBTYPE_UUID = 3;
-	/** Binary UUID Type @internal */
-	var BSON_BINARY_SUBTYPE_UUID_NEW = 4;
-	/** Binary MD5 Type @internal */
-	var BSON_BINARY_SUBTYPE_MD5 = 5;
-	/** Encrypted BSON type @internal */
-	var BSON_BINARY_SUBTYPE_ENCRYPTED = 6;
-	/** Column BSON type @internal */
-	var BSON_BINARY_SUBTYPE_COLUMN = 7;
-	/** Binary User Defined Type @internal */
-	var BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
-
 	function calculateObjectSize$1(object, serializeFunctions, ignoreUndefined) {
 	    var totalLength = 4 + 1;
 	    if (Array.isArray(object)) {
@@ -5637,7 +5625,7 @@ var BSON = (function (exports) {
 	            if (Math.floor(value) === value &&
 	                value >= JS_INT_MIN &&
 	                value <= JS_INT_MAX) {
-	                if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
+	                if (value >= BSON_INT32_MIN$1 && value <= BSON_INT32_MAX$1) {
 	                    // 32 bit
 	                    return (name != null ? buffer_1.byteLength(name, 'utf8') + 1 : 0) + (4 + 1);
 	                }
@@ -6139,6 +6127,9 @@ var BSON = (function (exports) {
 	                }
 	                else {
 	                    value = new Binary(buffer.slice(index, index + binarySize), subType);
+	                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
+	                        value = value.toUUID();
+	                    }
 	                }
 	            }
 	            else {
@@ -6164,8 +6155,11 @@ var BSON = (function (exports) {
 	                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, subType);
+	                    value = new Binary(buffer.slice(index, index + binarySize), subType);
 	                }
 	            }
 	            // Update the index
@@ -6492,8 +6486,8 @@ var BSON = (function (exports) {
 	    // We have an integer value
 	    // TODO(NODE-2529): Add support for big int
 	    if (Number.isInteger(value) &&
-	        value >= BSON_INT32_MIN &&
-	        value <= BSON_INT32_MAX) {
+	        value >= BSON_INT32_MIN$1 &&
+	        value <= BSON_INT32_MAX$1) {
 	        // If the value fits in 32 bits encode as int32
 	        // Set int type 32 bits or less
 	        buffer[index++] = BSON_DATA_INT;
@@ -7503,10 +7497,10 @@ var BSON = (function (exports) {
 	exports.BSON_DATA_SYMBOL = BSON_DATA_SYMBOL;
 	exports.BSON_DATA_TIMESTAMP = BSON_DATA_TIMESTAMP;
 	exports.BSON_DATA_UNDEFINED = BSON_DATA_UNDEFINED;
-	exports.BSON_INT32_MAX = BSON_INT32_MAX;
-	exports.BSON_INT32_MIN = BSON_INT32_MIN;
-	exports.BSON_INT64_MAX = BSON_INT64_MAX;
-	exports.BSON_INT64_MIN = BSON_INT64_MIN;
+	exports.BSON_INT32_MAX = BSON_INT32_MAX$1;
+	exports.BSON_INT32_MIN = BSON_INT32_MIN$1;
+	exports.BSON_INT64_MAX = BSON_INT64_MAX$1;
+	exports.BSON_INT64_MIN = BSON_INT64_MIN$1;
 	exports.Binary = Binary;
 	exports.Code = Code;
 	exports.DBRef = DBRef;