bson 4.5.1 → 4.6.0

package/dist/bson.browser.umd.js

@@ -2037,6 +2037,97 @@
 	buffer$1.INSPECT_MAX_BYTES;
 	buffer$1.kMaxLength;
 
+	/*! *****************************************************************************
+	Copyright (c) Microsoft Corporation.
+
+	Permission to use, copy, modify, and/or distribute this software for any
+	purpose with or without fee is hereby granted.
+
+	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+	PERFORMANCE OF THIS SOFTWARE.
+	***************************************************************************** */
+
+	/* global Reflect, Promise */
+	var _extendStatics = function extendStatics(d, b) {
+	  _extendStatics = Object.setPrototypeOf || {
+	    __proto__: []
+	  } instanceof Array && function (d, b) {
+	    d.__proto__ = b;
+	  } || function (d, b) {
+	    for (var p in b) {
+	      if (b.hasOwnProperty(p)) d[p] = b[p];
+	    }
+	  };
+
+	  return _extendStatics(d, b);
+	};
+
+	function __extends(d, b) {
+	  _extendStatics(d, b);
+
+	  function __() {
+	    this.constructor = d;
+	  }
+
+	  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+	}
+
+	var _assign = function __assign() {
+	  _assign = Object.assign || function __assign(t) {
+	    for (var s, i = 1, n = arguments.length; i < n; i++) {
+	      s = arguments[i];
+
+	      for (var p in s) {
+	        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+	      }
+	    }
+
+	    return t;
+	  };
+
+	  return _assign.apply(this, arguments);
+	};
+
+	/** @public */
+	var BSONError = /** @class */ (function (_super) {
+	    __extends(BSONError, _super);
+	    function BSONError(message) {
+	        var _this = _super.call(this, message) || this;
+	        Object.setPrototypeOf(_this, BSONError.prototype);
+	        return _this;
+	    }
+	    Object.defineProperty(BSONError.prototype, "name", {
+	        get: function () {
+	            return 'BSONError';
+	        },
+	        enumerable: false,
+	        configurable: true
+	    });
+	    return BSONError;
+	}(Error));
+	/** @public */
+	var BSONTypeError = /** @class */ (function (_super) {
+	    __extends(BSONTypeError, _super);
+	    function BSONTypeError(message) {
+	        var _this = _super.call(this, message) || this;
+	        Object.setPrototypeOf(_this, BSONTypeError.prototype);
+	        return _this;
+	    }
+	    Object.defineProperty(BSONTypeError.prototype, "name", {
+	        get: function () {
+	            return 'BSONTypeError';
+	        },
+	        enumerable: false,
+	        configurable: true
+	    });
+	    return BSONTypeError;
+	}(TypeError));
+
 	function checkForMath(potentialGlobal) {
 	    // eslint-disable-next-line eqeqeq
 	    return potentialGlobal && potentialGlobal.Math == Math && potentialGlobal;
@@ -2148,7 +2239,7 @@
 	 * @param potentialBuffer - The potential buffer
 	 * @returns Buffer the input if potentialBuffer is a buffer, or a buffer that
 	 * wraps a passed in Uint8Array
-	 * @throws TypeError If anything other than a Buffer or Uint8Array is passed in
+	 * @throws BSONTypeError If anything other than a Buffer or Uint8Array is passed in
 	 */
 	function ensureBuffer(potentialBuffer) {
 	    if (ArrayBuffer.isView(potentialBuffer)) {
@@ -2157,7 +2248,7 @@
 	    if (isAnyArrayBuffer(potentialBuffer)) {
 	        return buffer_1.from(potentialBuffer);
 	    }
-	    throw new TypeError('Must use either Buffer or TypedArray');
+	    throw new BSONTypeError('Must use either Buffer or TypedArray');
 	}
 
 	// Validation regex for v4 uuid (validates with or without dashes)
@@ -2167,7 +2258,7 @@
 	};
 	var uuidHexStringToBuffer = function (hexString) {
 	    if (!uuidValidateString(hexString)) {
-	        throw new TypeError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
+	        throw new BSONTypeError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
 	    }
 	    var sanitizedHexString = hexString.replace(/-/g, '');
 	    return buffer_1.from(sanitizedHexString, 'hex');
@@ -2215,7 +2306,7 @@
 	            this.id = uuidHexStringToBuffer(input);
 	        }
 	        else {
-	            throw new TypeError('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).');
+	            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", {
@@ -2255,14 +2346,13 @@
 	    };
 	    /**
 	     * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.
-	     * @internal
 	     */
 	    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
-	     * @internal
+	     * 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();
@@ -2374,7 +2464,7 @@
 	            !ArrayBuffer.isView(buffer) &&
 	            !(buffer instanceof ArrayBuffer) &&
 	            !Array.isArray(buffer)) {
-	            throw new TypeError('Binary can only be constructed from string, Buffer, TypedArray, or Array<number>');
+	            throw new BSONTypeError('Binary can only be constructed from string, Buffer, TypedArray, or Array<number>');
 	        }
 	        this.sub_type = subType !== null && subType !== void 0 ? subType : Binary.BSON_BINARY_SUBTYPE_DEFAULT;
 	        if (buffer == null) {
@@ -2406,10 +2496,10 @@
 	    Binary.prototype.put = function (byteValue) {
 	        // If it's a string and a has more than one character throw an error
 	        if (typeof byteValue === 'string' && byteValue.length !== 1) {
-	            throw new TypeError('only accepts single character String');
+	            throw new BSONTypeError('only accepts single character String');
 	        }
 	        else if (typeof byteValue !== 'number' && byteValue.length !== 1)
-	            throw new TypeError('only accepts single character Uint8Array or Array');
+	            throw new BSONTypeError('only accepts single character Uint8Array or Array');
 	        // Decode the byte value once
 	        var decodedByte;
 	        if (typeof byteValue === 'string') {
@@ -2422,7 +2512,7 @@
 	            decodedByte = byteValue[0];
 	        }
 	        if (decodedByte < 0 || decodedByte > 255) {
-	            throw new TypeError('only accepts number in a valid unsigned byte range 0-255');
+	            throw new BSONTypeError('only accepts number in a valid unsigned byte range 0-255');
 	        }
 	        if (this.buffer.length > this.position) {
 	            this.buffer[this.position++] = decodedByte;
@@ -2494,11 +2584,9 @@
 	    Binary.prototype.length = function () {
 	        return this.position;
 	    };
-	    /** @internal */
 	    Binary.prototype.toJSON = function () {
 	        return this.buffer.toString('base64');
 	    };
-	    /** @internal */
 	    Binary.prototype.toString = function (format) {
 	        return this.buffer.toString(format);
 	    };
@@ -2520,12 +2608,11 @@
 	            }
 	        };
 	    };
-	    /** @internal */
 	    Binary.prototype.toUUID = function () {
 	        if (this.sub_type === Binary.SUBTYPE_UUID) {
 	            return new UUID(this.buffer.slice(0, this.position));
 	        }
-	        throw new Error("Binary sub_type \"" + this.sub_type + "\" is not supported for converting to UUID. Only \"" + Binary.SUBTYPE_UUID + "\" is currently supported.");
+	        throw new BSONError("Binary sub_type \"" + this.sub_type + "\" is not supported for converting to UUID. Only \"" + Binary.SUBTYPE_UUID + "\" is currently supported.");
 	    };
 	    /** @internal */
 	    Binary.fromExtendedJSON = function (doc, options) {
@@ -2549,7 +2636,7 @@
 	            data = uuidHexStringToBuffer(doc.$uuid);
 	        }
 	        if (!data) {
-	            throw new TypeError("Unexpected Binary Extended JSON format " + JSON.stringify(doc));
+	            throw new BSONTypeError("Unexpected Binary Extended JSON format " + JSON.stringify(doc));
 	        }
 	        return new Binary(data, type);
 	    };
@@ -2580,6 +2667,10 @@
 	    Binary.SUBTYPE_UUID = 4;
 	    /** MD5 BSON type */
 	    Binary.SUBTYPE_MD5 = 5;
+	    /** Encrypted BSON type */
+	    Binary.SUBTYPE_ENCRYPTED = 6;
+	    /** Column BSON type */
+	    Binary.SUBTYPE_COLUMN = 7;
 	    /** User BSON type */
 	    Binary.SUBTYPE_USER_DEFINED = 128;
 	    return Binary;
@@ -2601,7 +2692,6 @@
 	        this.code = code;
 	        this.scope = scope;
 	    }
-	    /** @internal */
 	    Code.prototype.toJSON = function () {
 	        return { code: this.code, scope: this.scope };
 	    };
@@ -2673,7 +2763,6 @@
 	        enumerable: false,
 	        configurable: true
 	    });
-	    /** @internal */
 	    DBRef.prototype.toJSON = function () {
 	        var o = Object.assign({
 	            $ref: this.collection,
@@ -3700,7 +3789,7 @@
 	    return false;
 	}
 	function invalidErr(string, message) {
-	    throw new TypeError("\"" + string + "\" is not a valid Decimal128 string - " + message);
+	    throw new BSONTypeError("\"" + string + "\" is not a valid Decimal128 string - " + message);
 	}
 	/**
 	 * A class representation of the BSON Decimal128 type.
@@ -3767,7 +3856,7 @@
 	        // TODO: implementing a custom parsing for this, or refactoring the regex would yield
 	        //       further gains.
 	        if (representation.length >= 7000) {
-	            throw new TypeError('' + representation + ' not a valid Decimal128 string');
+	            throw new BSONTypeError('' + representation + ' not a valid Decimal128 string');
 	        }
 	        // Results
 	        var stringMatch = representation.match(PARSE_STRING_REGEXP);
@@ -3775,7 +3864,7 @@
 	        var nanMatch = representation.match(PARSE_NAN_REGEXP);
 	        // Validate the string
 	        if ((!stringMatch && !infMatch && !nanMatch) || representation.length === 0) {
-	            throw new TypeError('' + representation + ' not a valid Decimal128 string');
+	            throw new BSONTypeError('' + representation + ' not a valid Decimal128 string');
 	        }
 	        if (stringMatch) {
 	            // full_match = stringMatch[0]
@@ -3837,7 +3926,7 @@
 	            index = index + 1;
 	        }
 	        if (sawRadix && !nDigitsRead)
-	            throw new TypeError('' + representation + ' not a valid Decimal128 string');
+	            throw new BSONTypeError('' + representation + ' not a valid Decimal128 string');
 	        // Read exponent if exists
 	        if (representation[index] === 'e' || representation[index] === 'E') {
 	            // Read exponent digits
@@ -3868,7 +3957,7 @@
 	            lastDigit = nDigitsStored - 1;
 	            significantDigits = nDigits;
 	            if (significantDigits !== 1) {
-	                while (representation[firstNonZero + significantDigits - 1] === '0') {
+	                while (digits[firstNonZero + significantDigits - 1] === 0) {
 	                    significantDigits = significantDigits - 1;
 	                }
 	            }
@@ -4293,10 +4382,12 @@
 	    Double.prototype.valueOf = function () {
 	        return this.value;
 	    };
-	    /** @internal */
 	    Double.prototype.toJSON = function () {
 	        return this.value;
 	    };
+	    Double.prototype.toString = function (radix) {
+	        return this.value.toString(radix);
+	    };
 	    /** @internal */
 	    Double.prototype.toExtendedJSON = function (options) {
 	        if (options && (options.legacy || (options.relaxed && isFinite(this.value)))) {
@@ -4352,7 +4443,7 @@
 	        if (value instanceof Number) {
 	            value = value.valueOf();
 	        }
-	        this.value = +value;
+	        this.value = +value | 0;
 	    }
 	    /**
 	     * Access the number value.
@@ -4362,7 +4453,9 @@
 	    Int32.prototype.valueOf = function () {
 	        return this.value;
 	    };
-	    /** @internal */
+	    Int32.prototype.toString = function (radix) {
+	        return this.value.toString(radix);
+	    };
 	    Int32.prototype.toJSON = function () {
 	        return this.value;
 	    };
@@ -4456,50 +4549,57 @@
 	    /**
 	     * Create an ObjectId type
 	     *
-	     * @param id - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
+	     * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
 	     */
-	    function ObjectId(id) {
+	    function ObjectId(inputId) {
 	        if (!(this instanceof ObjectId))
-	            return new ObjectId(id);
-	        // Duck-typing to support ObjectId from different npm packages
-	        if (id instanceof ObjectId) {
-	            this[kId] = id.id;
-	            this.__id = id.__id;
-	        }
-	        if (typeof id === 'object' && id && 'id' in id) {
-	            if ('toHexString' in id && typeof id.toHexString === 'function') {
-	                this[kId] = buffer_1.from(id.toHexString(), 'hex');
+	            return new ObjectId(inputId);
+	        // workingId is set based on type of input and whether valid id exists for the input
+	        var workingId;
+	        if (typeof inputId === 'object' && inputId && 'id' in inputId) {
+	            if (typeof inputId.id !== 'string' && !ArrayBuffer.isView(inputId.id)) {
+	                throw new BSONTypeError('Argument passed in must have an id that is of type string or Buffer');
+	            }
+	            if ('toHexString' in inputId && typeof inputId.toHexString === 'function') {
+	                workingId = buffer_1.from(inputId.toHexString(), 'hex');
 	            }
 	            else {
-	                this[kId] = typeof id.id === 'string' ? buffer_1.from(id.id) : id.id;
+	                workingId = inputId.id;
 	            }
 	        }
-	        // The most common use case (blank id, new objectId instance)
-	        if (id == null || typeof id === 'number') {
+	        else {
+	            workingId = inputId;
+	        }
+	        // the following cases use workingId to construct an ObjectId
+	        if (workingId == null || typeof workingId === 'number') {
+	            // The most common use case (blank id, new objectId instance)
 	            // Generate a new id
-	            this[kId] = ObjectId.generate(typeof id === 'number' ? id : undefined);
-	            // If we are caching the hex string
-	            if (ObjectId.cacheHexString) {
-	                this.__id = this.id.toString('hex');
-	            }
+	            this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
 	        }
-	        if (ArrayBuffer.isView(id) && id.byteLength === 12) {
-	            this[kId] = ensureBuffer(id);
+	        else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
+	            this[kId] = ensureBuffer(workingId);
 	        }
-	        if (typeof id === 'string') {
-	            if (id.length === 12) {
-	                var bytes = buffer_1.from(id);
+	        else if (typeof workingId === 'string') {
+	            if (workingId.length === 12) {
+	                var bytes = buffer_1.from(workingId);
 	                if (bytes.byteLength === 12) {
 	                    this[kId] = bytes;
 	                }
+	                else {
+	                    throw new BSONTypeError('Argument passed in must be a string of 12 bytes');
+	                }
 	            }
-	            else if (id.length === 24 && checkForHexRegExp.test(id)) {
-	                this[kId] = buffer_1.from(id, 'hex');
+	            else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+	                this[kId] = buffer_1.from(workingId, 'hex');
 	            }
 	            else {
-	                throw new TypeError('Argument passed in must be a Buffer or string of 12 bytes or a string of 24 hex characters');
+	                throw new BSONTypeError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters');
 	            }
 	        }
+	        else {
+	            throw new BSONTypeError('Argument passed in does not match the accepted types');
+	        }
+	        // If we are caching the hex string
 	        if (ObjectId.cacheHexString) {
 	            this.__id = this.id.toString('hex');
 	        }
@@ -4563,7 +4663,7 @@
 	     */
 	    ObjectId.generate = function (time) {
 	        if ('number' !== typeof time) {
-	            time = ~~(Date.now() / 1000);
+	            time = Math.floor(Date.now() / 1000);
 	        }
 	        var inc = ObjectId.getInc();
 	        var buffer = buffer_1.alloc(12);
@@ -4589,7 +4689,6 @@
 	     * Converts the id into a 24 character hex string for printing
 	     *
 	     * @param format - The Buffer toString format parameter.
-	     * @internal
 	     */
 	    ObjectId.prototype.toString = function (format) {
 	        // Is the id a buffer then use the buffer toString method to return the format
@@ -4597,10 +4696,7 @@
 	            return this.id.toString(format);
 	        return this.toHexString();
 	    };
-	    /**
-	     * Converts to its JSON the 24 character hex string representation.
-	     * @internal
-	     */
+	    /** Converts to its JSON the 24 character hex string representation. */
 	    ObjectId.prototype.toJSON = function () {
 	        return this.toHexString();
 	    };
@@ -4666,7 +4762,7 @@
 	    ObjectId.createFromHexString = function (hexString) {
 	        // Throw an error if it's not a valid setup
 	        if (typeof hexString === 'undefined' || (hexString != null && hexString.length !== 24)) {
-	            throw new TypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');
+	            throw new BSONTypeError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');
 	        }
 	        return new ObjectId(buffer_1.from(hexString, 'hex'));
 	    };
@@ -4722,7 +4818,7 @@
 	        return "new ObjectId(\"" + this.toHexString() + "\")";
 	    };
 	    /** @internal */
-	    ObjectId.index = ~~(Math.random() * 0xffffff);
+	    ObjectId.index = Math.floor(Math.random() * 0xffffff);
 	    return ObjectId;
 	}());
 	// Deprecated methods
@@ -4757,6 +4853,12 @@
 	            return new BSONRegExp(pattern, options);
 	        this.pattern = pattern;
 	        this.options = alphabetize(options !== null && options !== void 0 ? options : '');
+	        if (this.pattern.indexOf('\x00') !== -1) {
+	            throw new BSONError("BSON Regex patterns cannot contain null bytes, found: " + JSON.stringify(this.pattern));
+	        }
+	        if (this.options.indexOf('\x00') !== -1) {
+	            throw new BSONError("BSON Regex options cannot contain null bytes, found: " + JSON.stringify(this.options));
+	        }
 	        // Validate options
 	        for (var i = 0; i < this.options.length; i++) {
 	            if (!(this.options[i] === 'i' ||
@@ -4765,7 +4867,7 @@
 	                this.options[i] === 'l' ||
 	                this.options[i] === 's' ||
 	                this.options[i] === 'u')) {
-	                throw new Error("The regular expression option [" + this.options[i] + "] is not supported");
+	                throw new BSONError("The regular expression option [" + this.options[i] + "] is not supported");
 	            }
 	        }
 	    }
@@ -4796,7 +4898,7 @@
 	        if ('$regularExpression' in doc) {
 	            return new BSONRegExp(doc.$regularExpression.pattern, BSONRegExp.parseOptions(doc.$regularExpression.options));
 	        }
-	        throw new TypeError("Unexpected BSONRegExp EJSON object form: " + JSON.stringify(doc));
+	        throw new BSONTypeError("Unexpected BSONRegExp EJSON object form: " + JSON.stringify(doc));
 	    };
 	    return BSONRegExp;
 	}());
@@ -4819,7 +4921,6 @@
 	    BSONSymbol.prototype.valueOf = function () {
 	        return this.value;
 	    };
-	    /** @internal */
 	    BSONSymbol.prototype.toString = function () {
 	        return this.value;
 	    };
@@ -4827,7 +4928,6 @@
 	    BSONSymbol.prototype.inspect = function () {
 	        return "new BSONSymbol(\"" + this.value + "\")";
 	    };
-	    /** @internal */
 	    BSONSymbol.prototype.toJSON = function () {
 	        return this.value;
 	    };
@@ -4847,46 +4947,6 @@
 	}());
 	Object.defineProperty(BSONSymbol.prototype, '_bsontype', { value: 'Symbol' });
 
-	/*! *****************************************************************************
-	Copyright (c) Microsoft Corporation.
-
-	Permission to use, copy, modify, and/or distribute this software for any
-	purpose with or without fee is hereby granted.
-
-	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-	PERFORMANCE OF THIS SOFTWARE.
-	***************************************************************************** */
-
-	/* global Reflect, Promise */
-	var _extendStatics = function extendStatics(d, b) {
-	  _extendStatics = Object.setPrototypeOf || {
-	    __proto__: []
-	  } instanceof Array && function (d, b) {
-	    d.__proto__ = b;
-	  } || function (d, b) {
-	    for (var p in b) {
-	      if (b.hasOwnProperty(p)) d[p] = b[p];
-	    }
-	  };
-
-	  return _extendStatics(d, b);
-	};
-
-	function __extends(d, b) {
-	  _extendStatics(d, b);
-
-	  function __() {
-	    this.constructor = d;
-	  }
-
-	  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-	}
-
 	/** @public */
 	var LongWithoutOverridesClass = Long;
 	/** @public */
@@ -5101,7 +5161,7 @@
 	            var current = props[props.length - 1];
 	            var leadingSpace = ' '.repeat(leadingPart.length + alreadySeen.length / 2);
 	            var dashes = '-'.repeat(circularPart.length + (alreadySeen.length + current.length) / 2 - 1);
-	            throw new TypeError('Converting circular structure to EJSON:\n' +
+	            throw new BSONTypeError('Converting circular structure to EJSON:\n' +
 	                ("    " + leadingPart + alreadySeen + circularPart + current + "\n") +
 	                ("    " + leadingSpace + "\\" + dashes + "/"));
 	        }
@@ -5174,7 +5234,7 @@
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	function serializeDocument(doc, options) {
 	    if (doc == null || typeof doc !== 'object')
-	        throw new Error('not an object instance');
+	        throw new BSONError('not an object instance');
 	    var bsontype = doc._bsontype;
 	    if (typeof bsontype === 'undefined') {
 	        // It's a regular object. Recursively serialize its property values.
@@ -5201,7 +5261,7 @@
 	            // Copy the object into this library's version of that type.
 	            var mapper = BSON_TYPE_MAPPINGS[doc._bsontype];
 	            if (!mapper) {
-	                throw new TypeError('Unrecognized or invalid _bsontype: ' + doc._bsontype);
+	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + doc._bsontype);
 	            }
 	            outDoc = mapper(outDoc);
 	        }
@@ -5215,7 +5275,7 @@
 	        return outDoc.toExtendedJSON(options);
 	    }
 	    else {
-	        throw new Error('_bsontype must be a string, but was: ' + typeof bsontype);
+	        throw new BSONError('_bsontype must be a string, but was: ' + typeof bsontype);
 	    }
 	}
 	/**
@@ -5250,7 +5310,12 @@
 	            finalOptions.strict = !finalOptions.relaxed;
 	        if (typeof finalOptions.strict === 'boolean')
 	            finalOptions.relaxed = !finalOptions.strict;
-	        return JSON.parse(text, function (_key, value) { return deserializeValue(value, finalOptions); });
+	        return JSON.parse(text, function (key, value) {
+	            if (key.indexOf('\x00') !== -1) {
+	                throw new BSONError("BSON Document field names cannot contain null bytes, found: " + JSON.stringify(key));
+	            }
+	            return deserializeValue(value, finalOptions);
+	        });
 	    }
 	    EJSON.parse = parse;
 	    /**
@@ -5508,6 +5573,10 @@
 	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;
 
@@ -5752,20 +5821,20 @@
 	        (buffer[index + 2] << 16) |
 	        (buffer[index + 3] << 24);
 	    if (size < 5) {
-	        throw new Error("bson size must be >= 5, is " + size);
+	        throw new BSONError("bson size must be >= 5, is " + size);
 	    }
 	    if (options.allowObjectSmallerThanBufferSize && buffer.length < size) {
-	        throw new Error("buffer length " + buffer.length + " must be >= bson size " + size);
+	        throw new BSONError("buffer length " + buffer.length + " must be >= bson size " + size);
 	    }
 	    if (!options.allowObjectSmallerThanBufferSize && buffer.length !== size) {
-	        throw new Error("buffer length " + buffer.length + " must === bson size " + size);
+	        throw new BSONError("buffer length " + buffer.length + " must === bson size " + size);
 	    }
 	    if (size + index > buffer.byteLength) {
-	        throw new Error("(bson size " + size + " + options.index " + index + " must be <= buffer length " + buffer.byteLength + ")");
+	        throw new BSONError("(bson size " + size + " + options.index " + index + " must be <= buffer length " + buffer.byteLength + ")");
 	    }
 	    // Illegal end value
 	    if (buffer[index + size - 1] !== 0) {
-	        throw new Error("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");
+	        throw new BSONError("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");
 	    }
 	    // Start deserializtion
 	    return deserializeObject(buffer, index, options, isArray);
@@ -5784,16 +5853,53 @@
 	    var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
 	    var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
 	    var promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
+	    // Ensures default validation option if none given
+	    var validation = options.validation == null ? { utf8: true } : options.validation;
+	    // Shows if global utf-8 validation is enabled or disabled
+	    var globalUTFValidation = true;
+	    // Reflects utf-8 validation setting regardless of global or specific key validation
+	    var validationSetting;
+	    // Set of keys either to enable or disable validation on
+	    var utf8KeysSet = new Set();
+	    // Check for boolean uniformity and empty validation option
+	    var utf8ValidatedKeys = validation.utf8;
+	    if (typeof utf8ValidatedKeys === 'boolean') {
+	        validationSetting = utf8ValidatedKeys;
+	    }
+	    else {
+	        globalUTFValidation = false;
+	        var utf8ValidationValues = Object.keys(utf8ValidatedKeys).map(function (key) {
+	            return utf8ValidatedKeys[key];
+	        });
+	        if (utf8ValidationValues.length === 0) {
+	            throw new BSONError('UTF-8 validation setting cannot be empty');
+	        }
+	        if (typeof utf8ValidationValues[0] !== 'boolean') {
+	            throw new BSONError('Invalid UTF-8 validation option, must specify boolean values');
+	        }
+	        validationSetting = utf8ValidationValues[0];
+	        // Ensures boolean uniformity in utf-8 validation (all true or all false)
+	        if (!utf8ValidationValues.every(function (item) { return item === validationSetting; })) {
+	            throw new BSONError('Invalid UTF-8 validation option - keys must be all true or all false');
+	        }
+	    }
+	    // Add keys to set that will either be validated or not based on validationSetting
+	    if (!globalUTFValidation) {
+	        for (var _i = 0, _a = Object.keys(utf8ValidatedKeys); _i < _a.length; _i++) {
+	            var key = _a[_i];
+	            utf8KeysSet.add(key);
+	        }
+	    }
 	    // Set the start index
 	    var startIndex = index;
 	    // Validate that we have at least 4 bytes of buffer
 	    if (buffer.length < 5)
-	        throw new Error('corrupt bson message < 5 bytes long');
+	        throw new BSONError('corrupt bson message < 5 bytes long');
 	    // Read the document size
 	    var size = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
 	    // Ensure buffer is valid size
 	    if (size < 5 || size > buffer.length)
-	        throw new Error('corrupt bson message');
+	        throw new BSONError('corrupt bson message');
 	    // Create holding object
 	    var object = isArray ? [] : {};
 	    // Used for arrays to skip having to perform utf8 decoding
@@ -5815,8 +5921,17 @@
 	        }
 	        // If are at the end of the buffer there is a problem with the document
 	        if (i >= buffer.byteLength)
-	            throw new Error('Bad BSON Document: illegal CString');
+	            throw new BSONError('Bad BSON Document: illegal CString');
+	        // Represents the key
 	        var name = isArray ? arrayIndex++ : buffer.toString('utf8', index, i);
+	        // shouldValidateKey is true if the key should be validated, false otherwise
+	        var shouldValidateKey = true;
+	        if (globalUTFValidation || utf8KeysSet.has(name)) {
+	            shouldValidateKey = validationSetting;
+	        }
+	        else {
+	            shouldValidateKey = !validationSetting;
+	        }
 	        if (isPossibleDBRef !== false && name[0] === '$') {
 	            isPossibleDBRef = allowedDBRefKeys.test(name);
 	        }
@@ -5829,17 +5944,10 @@
 	                (buffer[index++] << 24);
 	            if (stringSize <= 0 ||
 	                stringSize > buffer.length - index ||
-	                buffer[index + stringSize - 1] !== 0)
-	                throw new Error('bad string length in bson');
-	            value = buffer.toString('utf8', index, index + stringSize - 1);
-	            for (var i_1 = 0; i_1 < value.length; i_1++) {
-	                if (value.charCodeAt(i_1) === 0xfffd) {
-	                    if (!validateUtf8(buffer, index, index + stringSize - 1)) {
-	                        throw new Error('Invalid UTF-8 string in BSON document');
-	                    }
-	                    break;
-	                }
+	                buffer[index + stringSize - 1] !== 0) {
+	                throw new BSONError('bad string length in bson');
 	            }
+	            value = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
 	            index = index + stringSize;
 	        }
 	        else if (elementType === BSON_DATA_OID) {
@@ -5879,7 +5987,7 @@
 	        }
 	        else if (elementType === BSON_DATA_BOOLEAN) {
 	            if (buffer[index] !== 0 && buffer[index] !== 1)
-	                throw new Error('illegal boolean type value');
+	                throw new BSONError('illegal boolean type value');
 	            value = buffer[index++] === 1;
 	        }
 	        else if (elementType === BSON_DATA_OBJECT) {
@@ -5889,13 +5997,17 @@
 	                (buffer[index + 2] << 16) |
 	                (buffer[index + 3] << 24);
 	            if (objectSize <= 0 || objectSize > buffer.length - index)
-	                throw new Error('bad embedded document length in bson');
+	                throw new BSONError('bad embedded document length in bson');
 	            // We have a raw value
 	            if (raw) {
 	                value = buffer.slice(index, index + objectSize);
 	            }
 	            else {
-	                value = deserializeObject(buffer, _index, options, false);
+	                var objectOptions = options;
+	                if (!globalUTFValidation) {
+	                    objectOptions = _assign(_assign({}, options), { validation: { utf8: shouldValidateKey } });
+	                }
+	                value = deserializeObject(buffer, _index, objectOptions, false);
 	            }
 	            index = index + objectSize;
 	        }
@@ -5916,12 +6028,15 @@
 	                }
 	                arrayOptions['raw'] = true;
 	            }
+	            if (!globalUTFValidation) {
+	                arrayOptions = _assign(_assign({}, arrayOptions), { validation: { utf8: shouldValidateKey } });
+	            }
 	            value = deserializeObject(buffer, _index, arrayOptions, true);
 	            index = index + objectSize;
 	            if (buffer[index - 1] !== 0)
-	                throw new Error('invalid array terminator byte');
+	                throw new BSONError('invalid array terminator byte');
 	            if (index !== stopIndex)
-	                throw new Error('corrupted array bson');
+	                throw new BSONError('corrupted array bson');
 	        }
 	        else if (elementType === BSON_DATA_UNDEFINED) {
 	            value = undefined;
@@ -5977,10 +6092,10 @@
 	            var subType = buffer[index++];
 	            // Did we have a negative binary size, throw
 	            if (binarySize < 0)
-	                throw new Error('Negative binary type element size found');
+	                throw new BSONError('Negative binary type element size found');
 	            // Is the length longer than the document
 	            if (binarySize > buffer.byteLength)
-	                throw new Error('Binary type size larger than document size');
+	                throw new BSONError('Binary type size larger than document size');
 	            // Decode as raw Buffer object if options specifies it
 	            if (buffer['slice'] != null) {
 	                // If we have subtype 2 skip the 4 bytes for the size
@@ -5991,11 +6106,11 @@
 	                            (buffer[index++] << 16) |
 	                            (buffer[index++] << 24);
 	                    if (binarySize < 0)
-	                        throw new Error('Negative binary type element size found for subtype 0x02');
+	                        throw new BSONError('Negative binary type element size found for subtype 0x02');
 	                    if (binarySize > totalBinarySize - 4)
-	                        throw new Error('Binary type with subtype 0x02 contains too long binary size');
+	                        throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
 	                    if (binarySize < totalBinarySize - 4)
-	                        throw new Error('Binary type with subtype 0x02 contains too short binary size');
+	                        throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
 	                }
 	                if (promoteBuffers && promoteValues) {
 	                    value = buffer.slice(index, index + binarySize);
@@ -6014,11 +6129,11 @@
 	                            (buffer[index++] << 16) |
 	                            (buffer[index++] << 24);
 	                    if (binarySize < 0)
-	                        throw new Error('Negative binary type element size found for subtype 0x02');
+	                        throw new BSONError('Negative binary type element size found for subtype 0x02');
 	                    if (binarySize > totalBinarySize - 4)
-	                        throw new Error('Binary type with subtype 0x02 contains too long binary size');
+	                        throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
 	                    if (binarySize < totalBinarySize - 4)
-	                        throw new Error('Binary type with subtype 0x02 contains too short binary size');
+	                        throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
 	                }
 	                // Copy the data
 	                for (i = 0; i < binarySize; i++) {
@@ -6043,7 +6158,7 @@
 	            }
 	            // If are at the end of the buffer there is a problem with the document
 	            if (i >= buffer.length)
-	                throw new Error('Bad BSON Document: illegal CString');
+	                throw new BSONError('Bad BSON Document: illegal CString');
 	            // Return the C string
 	            var source = buffer.toString('utf8', index, i);
 	            // Create the regexp
@@ -6056,7 +6171,7 @@
 	            }
 	            // If are at the end of the buffer there is a problem with the document
 	            if (i >= buffer.length)
-	                throw new Error('Bad BSON Document: illegal CString');
+	                throw new BSONError('Bad BSON Document: illegal CString');
 	            // Return the C string
 	            var regExpOptions = buffer.toString('utf8', index, i);
 	            index = i + 1;
@@ -6087,7 +6202,7 @@
 	            }
 	            // If are at the end of the buffer there is a problem with the document
 	            if (i >= buffer.length)
-	                throw new Error('Bad BSON Document: illegal CString');
+	                throw new BSONError('Bad BSON Document: illegal CString');
 	            // Return the C string
 	            var source = buffer.toString('utf8', index, i);
 	            index = i + 1;
@@ -6099,7 +6214,7 @@
 	            }
 	            // If are at the end of the buffer there is a problem with the document
 	            if (i >= buffer.length)
-	                throw new Error('Bad BSON Document: illegal CString');
+	                throw new BSONError('Bad BSON Document: illegal CString');
 	            // Return the C string
 	            var regExpOptions = buffer.toString('utf8', index, i);
 	            index = i + 1;
@@ -6113,9 +6228,10 @@
 	                (buffer[index++] << 24);
 	            if (stringSize <= 0 ||
 	                stringSize > buffer.length - index ||
-	                buffer[index + stringSize - 1] !== 0)
-	                throw new Error('bad string length in bson');
-	            var symbol = buffer.toString('utf8', index, index + stringSize - 1);
+	                buffer[index + stringSize - 1] !== 0) {
+	                throw new BSONError('bad string length in bson');
+	            }
+	            var symbol = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
 	            value = promoteValues ? symbol : new BSONSymbol(symbol);
 	            index = index + stringSize;
 	        }
@@ -6143,9 +6259,10 @@
 	                (buffer[index++] << 24);
 	            if (stringSize <= 0 ||
 	                stringSize > buffer.length - index ||
-	                buffer[index + stringSize - 1] !== 0)
-	                throw new Error('bad string length in bson');
-	            var functionString = buffer.toString('utf8', index, index + stringSize - 1);
+	                buffer[index + stringSize - 1] !== 0) {
+	                throw new BSONError('bad string length in bson');
+	            }
+	            var functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
 	            // If we are evaluating the functions
 	            if (evalFunctions) {
 	                // If we have cache enabled let's look for the md5 of the function in the cache
@@ -6170,7 +6287,7 @@
 	                (buffer[index++] << 24);
 	            // Element cannot be shorter than totalSize + stringSize + documentSize + terminator
 	            if (totalSize < 4 + 4 + 4 + 1) {
-	                throw new Error('code_w_scope total size shorter minimum expected length');
+	                throw new BSONError('code_w_scope total size shorter minimum expected length');
 	            }
 	            // Get the code string size
 	            var stringSize = buffer[index++] |
@@ -6180,10 +6297,11 @@
 	            // Check if we have a valid string
 	            if (stringSize <= 0 ||
 	                stringSize > buffer.length - index ||
-	                buffer[index + stringSize - 1] !== 0)
-	                throw new Error('bad string length in bson');
+	                buffer[index + stringSize - 1] !== 0) {
+	                throw new BSONError('bad string length in bson');
+	            }
 	            // Javascript function
-	            var functionString = buffer.toString('utf8', index, index + stringSize - 1);
+	            var functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
 	            // Update parse index position
 	            index = index + stringSize;
 	            // Parse the element
@@ -6199,11 +6317,11 @@
 	            index = index + objectSize;
 	            // Check if field length is too short
 	            if (totalSize < 4 + 4 + objectSize + stringSize) {
-	                throw new Error('code_w_scope total size is too short, truncating scope');
+	                throw new BSONError('code_w_scope total size is too short, truncating scope');
 	            }
 	            // Check if totalSize field is too long
 	            if (totalSize > 4 + 4 + objectSize + stringSize) {
-	                throw new Error('code_w_scope total size is too long, clips outer document');
+	                throw new BSONError('code_w_scope total size is too long, clips outer document');
 	            }
 	            // If we are evaluating the functions
 	            if (evalFunctions) {
@@ -6231,10 +6349,12 @@
 	            if (stringSize <= 0 ||
 	                stringSize > buffer.length - index ||
 	                buffer[index + stringSize - 1] !== 0)
-	                throw new Error('bad string length in bson');
+	                throw new BSONError('bad string length in bson');
 	            // Namespace
-	            if (!validateUtf8(buffer, index, index + stringSize - 1)) {
-	                throw new Error('Invalid UTF-8 string in BSON document');
+	            if (validation != null && validation.utf8) {
+	                if (!validateUtf8(buffer, index, index + stringSize - 1)) {
+	                    throw new BSONError('Invalid UTF-8 string in BSON document');
+	                }
 	            }
 	            var namespace = buffer.toString('utf8', index, index + stringSize - 1);
 	            // Update parse index position
@@ -6249,7 +6369,7 @@
 	            value = new DBRef(namespace, oid);
 	        }
 	        else {
-	            throw new Error('Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname "' + name + '"');
+	            throw new BSONError('Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname "' + name + '"');
 	        }
 	        if (name === '__proto__') {
 	            Object.defineProperty(object, name, {
@@ -6266,8 +6386,8 @@
 	    // Check if the deserialization was against a valid array/object
 	    if (size !== index - startIndex) {
 	        if (isArray)
-	            throw new Error('corrupt array bson');
-	        throw new Error('corrupt object bson');
+	            throw new BSONError('corrupt array bson');
+	        throw new BSONError('corrupt object bson');
 	    }
 	    // if we did not find "$ref", "$id", "$db", or found an extraneous $key, don't make a DBRef
 	    if (!isPossibleDBRef)
@@ -6296,6 +6416,21 @@
 	    // Set the object
 	    return functionCache[functionString].bind(object);
 	}
+	function getValidatedString(buffer, start, end, shouldValidateUtf8) {
+	    var value = buffer.toString('utf8', start, end);
+	    // if utf8 validation is on, do the check
+	    if (shouldValidateUtf8) {
+	        for (var i = 0; i < value.length; i++) {
+	            if (value.charCodeAt(i) === 0xfffd) {
+	                if (!validateUtf8(buffer, start, end)) {
+	                    throw new BSONError('Invalid UTF-8 string in BSON document');
+	                }
+	                break;
+	            }
+	        }
+	    }
+	    return value;
+	}
 
 	// Copyright (c) 2008, Fair Oaks Labs, Inc.
 	function writeIEEE754(buffer, value, offset, endian, mLen, nBytes) {
@@ -6580,7 +6715,7 @@
 	        buffer.set(value.id.subarray(0, 12), index);
 	    }
 	    else {
-	        throw new TypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
+	        throw new BSONTypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
 	    }
 	    // Adjust index
 	    return index + 12;
@@ -6619,7 +6754,7 @@
 	    if (path === void 0) { path = []; }
 	    for (var i = 0; i < path.length; i++) {
 	        if (path[i] === value)
-	            throw new Error('cyclic dependency detected');
+	            throw new BSONError('cyclic dependency detected');
 	    }
 	    // Push value to stack
 	    path.push(value);
@@ -6922,7 +7057,7 @@
 	            // Is there an override value
 	            if (value && value.toBSON) {
 	                if (typeof value.toBSON !== 'function')
-	                    throw new TypeError('toBSON is not a function');
+	                    throw new BSONTypeError('toBSON is not a function');
 	                value = value.toBSON();
 	            }
 	            if (typeof value === 'string') {
@@ -6932,7 +7067,7 @@
 	                index = serializeNumber(buffer, key, value, index, true);
 	            }
 	            else if (typeof value === 'bigint') {
-	                throw new TypeError('Unsupported type BigInt, please use Decimal128');
+	                throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
 	            }
 	            else if (typeof value === 'boolean') {
 	                index = serializeBoolean(buffer, key, value, index, true);
@@ -6994,7 +7129,7 @@
 	                index = serializeMinMax(buffer, key, value, index, true);
 	            }
 	            else if (typeof value['_bsontype'] !== 'undefined') {
-	                throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
 	            }
 	        }
 	    }
@@ -7036,7 +7171,7 @@
 	                index = serializeNumber(buffer, key, value, index);
 	            }
 	            else if (type === 'bigint' || isBigInt64Array(value) || isBigUInt64Array(value)) {
-	                throw new TypeError('Unsupported type BigInt, please use Decimal128');
+	                throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
 	            }
 	            else if (type === 'boolean') {
 	                index = serializeBoolean(buffer, key, value, index);
@@ -7093,7 +7228,7 @@
 	                index = serializeMinMax(buffer, key, value, index);
 	            }
 	            else if (typeof value['_bsontype'] !== 'undefined') {
-	                throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
 	            }
 	        }
 	    }
@@ -7101,10 +7236,10 @@
 	        // Did we provide a custom serialization method
 	        if (object.toBSON) {
 	            if (typeof object.toBSON !== 'function')
-	                throw new TypeError('toBSON is not a function');
+	                throw new BSONTypeError('toBSON is not a function');
 	            object = object.toBSON();
 	            if (object != null && typeof object !== 'object')
-	                throw new TypeError('toBSON function did not return an object');
+	                throw new BSONTypeError('toBSON function did not return an object');
 	        }
 	        // Iterate over all the keys
 	        for (var key in object) {
@@ -7112,7 +7247,7 @@
 	            // Is there an override value
 	            if (value && value.toBSON) {
 	                if (typeof value.toBSON !== 'function')
-	                    throw new TypeError('toBSON is not a function');
+	                    throw new BSONTypeError('toBSON is not a function');
 	                value = value.toBSON();
 	            }
 	            // Check the type of the value
@@ -7140,7 +7275,7 @@
 	                index = serializeNumber(buffer, key, value, index);
 	            }
 	            else if (type === 'bigint') {
-	                throw new TypeError('Unsupported type BigInt, please use Decimal128');
+	                throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
 	            }
 	            else if (type === 'boolean') {
 	                index = serializeBoolean(buffer, key, value, index);
@@ -7201,7 +7336,7 @@
 	                index = serializeMinMax(buffer, key, value, index);
 	            }
 	            else if (typeof value['_bsontype'] !== 'undefined') {
-	                throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+	                throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
 	            }
 	        }
 	    }
@@ -7374,13 +7509,19 @@
 	    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
 	    deserialize: deserialize,
 	    calculateObjectSize: calculateObjectSize,
-	    deserializeStream: deserializeStream
+	    deserializeStream: deserializeStream,
+	    BSONError: BSONError,
+	    BSONTypeError: BSONTypeError
 	};
 
+	exports.BSONError = BSONError;
 	exports.BSONRegExp = BSONRegExp;
 	exports.BSONSymbol = BSONSymbol;
+	exports.BSONTypeError = BSONTypeError;
 	exports.BSON_BINARY_SUBTYPE_BYTE_ARRAY = BSON_BINARY_SUBTYPE_BYTE_ARRAY;
+	exports.BSON_BINARY_SUBTYPE_COLUMN = BSON_BINARY_SUBTYPE_COLUMN;
 	exports.BSON_BINARY_SUBTYPE_DEFAULT = BSON_BINARY_SUBTYPE_DEFAULT;
+	exports.BSON_BINARY_SUBTYPE_ENCRYPTED = BSON_BINARY_SUBTYPE_ENCRYPTED;
 	exports.BSON_BINARY_SUBTYPE_FUNCTION = BSON_BINARY_SUBTYPE_FUNCTION;
 	exports.BSON_BINARY_SUBTYPE_MD5 = BSON_BINARY_SUBTYPE_MD5;
 	exports.BSON_BINARY_SUBTYPE_USER_DEFINED = BSON_BINARY_SUBTYPE_USER_DEFINED;