bson 4.5.2 → 4.6.1

package/dist/bson.esm.js

@@ -1,5 +1,96 @@
 import { Buffer } from 'buffer';
 
+/*! *****************************************************************************
+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;
@@ -111,7 +202,7 @@ function deprecate(fn, message) {
  * @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)) {
@@ -120,7 +211,7 @@ function ensureBuffer(potentialBuffer) {
     if (isAnyArrayBuffer(potentialBuffer)) {
         return Buffer.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)
@@ -130,7 +221,7 @@ var uuidValidateString = function (str) {
 };
 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.from(sanitizedHexString, 'hex');
@@ -178,7 +269,7 @@ var UUID = /** @class */ (function () {
             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", {
@@ -336,7 +427,7 @@ var Binary = /** @class */ (function () {
             !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) {
@@ -368,10 +459,10 @@ var Binary = /** @class */ (function () {
     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') {
@@ -384,7 +475,7 @@ var Binary = /** @class */ (function () {
             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;
@@ -484,7 +575,7 @@ var Binary = /** @class */ (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) {
@@ -508,7 +599,7 @@ var Binary = /** @class */ (function () {
             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);
     };
@@ -539,6 +630,10 @@ var Binary = /** @class */ (function () {
     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;
@@ -1657,7 +1752,7 @@ function lessThan(left, right) {
     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.
@@ -1674,9 +1769,15 @@ var Decimal128 = /** @class */ (function () {
         if (typeof bytes === 'string') {
             this.bytes = Decimal128.fromString(bytes).bytes;
         }
-        else {
+        else if (isUint8Array(bytes)) {
+            if (bytes.byteLength !== 16) {
+                throw new BSONTypeError('Decimal128 must take a Buffer of 16 bytes');
+            }
             this.bytes = bytes;
         }
+        else {
+            throw new BSONTypeError('Decimal128 must take a Buffer or string');
+        }
     }
     /**
      * Create a Decimal128 instance from a string representation
@@ -1724,7 +1825,7 @@ var Decimal128 = /** @class */ (function () {
         // 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);
@@ -1732,7 +1833,7 @@ var Decimal128 = /** @class */ (function () {
         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]
@@ -1794,7 +1895,7 @@ var Decimal128 = /** @class */ (function () {
             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
@@ -2311,7 +2412,7 @@ var Int32 = /** @class */ (function () {
         if (value instanceof Number) {
             value = value.valueOf();
         }
-        this.value = +value;
+        this.value = +value | 0;
     }
     /**
      * Access the number value.
@@ -2417,50 +2518,57 @@ var ObjectId = /** @class */ (function () {
     /**
      * 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.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.from(inputId.toHexString(), 'hex');
             }
             else {
-                this[kId] = typeof id.id === 'string' ? Buffer.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.from(id);
+        else if (typeof workingId === 'string') {
+            if (workingId.length === 12) {
+                var bytes = Buffer.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.from(id, 'hex');
+            else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+                this[kId] = Buffer.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');
         }
@@ -2524,7 +2632,7 @@ var ObjectId = /** @class */ (function () {
      */
     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.alloc(12);
@@ -2623,7 +2731,7 @@ var ObjectId = /** @class */ (function () {
     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.from(hexString, 'hex'));
     };
@@ -2635,26 +2743,13 @@ var ObjectId = /** @class */ (function () {
     ObjectId.isValid = function (id) {
         if (id == null)
             return false;
-        if (typeof id === 'number') {
-            return true;
-        }
-        if (typeof id === 'string') {
-            return id.length === 12 || (id.length === 24 && checkForHexRegExp.test(id));
-        }
-        if (id instanceof ObjectId) {
-            return true;
-        }
-        if (isUint8Array(id) && id.length === 12) {
+        try {
+            new ObjectId(id);
             return true;
         }
-        // Duck-Typing detection of ObjectId like objects
-        if (typeof id === 'object' && 'toHexString' in id && typeof id.toHexString === 'function') {
-            if (typeof id.id === 'string') {
-                return id.id.length === 12;
-            }
-            return id.toHexString().length === 24 && checkForHexRegExp.test(id.id.toString('hex'));
+        catch (_a) {
+            return false;
         }
-        return false;
     };
     /** @internal */
     ObjectId.prototype.toExtendedJSON = function () {
@@ -2679,7 +2774,7 @@ var ObjectId = /** @class */ (function () {
         return "new ObjectId(\"" + this.toHexString() + "\")";
     };
     /** @internal */
-    ObjectId.index = ~~(Math.random() * 0xffffff);
+    ObjectId.index = Math.floor(Math.random() * 0xffffff);
     return ObjectId;
 }());
 // Deprecated methods
@@ -2714,6 +2809,12 @@ var BSONRegExp = /** @class */ (function () {
             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' ||
@@ -2722,7 +2823,7 @@ var BSONRegExp = /** @class */ (function () {
                 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");
             }
         }
     }
@@ -2753,7 +2854,7 @@ var BSONRegExp = /** @class */ (function () {
         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;
 }());
@@ -2802,46 +2903,6 @@ var BSONSymbol = /** @class */ (function () {
 }());
 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 */
@@ -3056,7 +3117,7 @@ function serializeValue(value, options) {
             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 + "/"));
         }
@@ -3129,7 +3190,7 @@ var BSON_TYPE_MAPPINGS = {
 // 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.
@@ -3156,7 +3217,7 @@ function serializeDocument(doc, options) {
             // 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);
         }
@@ -3170,7 +3231,7 @@ function serializeDocument(doc, options) {
         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);
     }
 }
 /**
@@ -3205,7 +3266,12 @@ var EJSON;
             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;
     /**
@@ -3463,6 +3529,10 @@ var BSON_BINARY_SUBTYPE_UUID = 3;
 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;
 
@@ -3475,7 +3545,7 @@ function calculateObjectSize$1(object, serializeFunctions, ignoreUndefined) {
     }
     else {
         // If we have toBSON defined, override the current object
-        if (object.toBSON) {
+        if (typeof (object === null || object === void 0 ? void 0 : object.toBSON) === 'function') {
             object = object.toBSON();
         }
         // Calculate size
@@ -3493,7 +3563,7 @@ value, serializeFunctions, isArray, ignoreUndefined) {
     if (isArray === void 0) { isArray = false; }
     if (ignoreUndefined === void 0) { ignoreUndefined = false; }
     // If we have toBSON defined, override the current object
-    if (value && value.toBSON) {
+    if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
         value = value.toBSON();
     }
     switch (typeof value) {
@@ -3707,20 +3777,20 @@ function deserialize$1(buffer, options, isArray) {
         (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);
@@ -3739,16 +3809,53 @@ function deserializeObject(buffer, index, options, isArray) {
     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
@@ -3770,8 +3877,17 @@ function deserializeObject(buffer, index, options, isArray) {
         }
         // 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);
         }
@@ -3784,17 +3900,10 @@ function deserializeObject(buffer, index, options, isArray) {
                 (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) {
@@ -3834,7 +3943,7 @@ function deserializeObject(buffer, index, options, isArray) {
         }
         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) {
@@ -3844,13 +3953,17 @@ function deserializeObject(buffer, index, options, isArray) {
                 (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;
         }
@@ -3871,12 +3984,15 @@ function deserializeObject(buffer, index, options, isArray) {
                 }
                 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;
@@ -3932,10 +4048,10 @@ function deserializeObject(buffer, index, options, isArray) {
             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
@@ -3946,11 +4062,11 @@ function deserializeObject(buffer, index, options, isArray) {
                             (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);
@@ -3969,11 +4085,11 @@ function deserializeObject(buffer, index, options, isArray) {
                             (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++) {
@@ -3998,7 +4114,7 @@ function deserializeObject(buffer, index, options, isArray) {
             }
             // 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
@@ -4011,7 +4127,7 @@ function deserializeObject(buffer, index, options, isArray) {
             }
             // 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;
@@ -4042,7 +4158,7 @@ function deserializeObject(buffer, index, options, isArray) {
             }
             // 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;
@@ -4054,7 +4170,7 @@ function deserializeObject(buffer, index, options, isArray) {
             }
             // 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;
@@ -4068,9 +4184,10 @@ function deserializeObject(buffer, index, options, isArray) {
                 (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;
         }
@@ -4098,9 +4215,10 @@ function deserializeObject(buffer, index, options, isArray) {
                 (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
@@ -4125,7 +4243,7 @@ function deserializeObject(buffer, index, options, isArray) {
                 (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++] |
@@ -4135,10 +4253,11 @@ function deserializeObject(buffer, index, options, isArray) {
             // 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
@@ -4154,11 +4273,11 @@ function deserializeObject(buffer, index, options, isArray) {
             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) {
@@ -4186,10 +4305,12 @@ function deserializeObject(buffer, index, options, isArray) {
             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
@@ -4204,7 +4325,7 @@ function deserializeObject(buffer, index, options, isArray) {
             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, {
@@ -4221,8 +4342,8 @@ function deserializeObject(buffer, index, options, isArray) {
     // 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)
@@ -4251,6 +4372,21 @@ function isolateEval(functionString, functionCache, object) {
     // 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) {
@@ -4535,7 +4671,7 @@ function serializeObjectId(buffer, key, value, index, isArray) {
         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;
@@ -4574,7 +4710,7 @@ function serializeObject(buffer, key, value, index, checkKeys, depth, serializeF
     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);
@@ -4875,9 +5011,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             var key = '' + i;
             var value = object[i];
             // Is there an override value
-            if (value && value.toBSON) {
-                if (typeof value.toBSON !== 'function')
-                    throw new TypeError('toBSON is not a function');
+            if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
                 value = value.toBSON();
             }
             if (typeof value === 'string') {
@@ -4887,7 +5021,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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);
@@ -4949,7 +5083,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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']);
             }
         }
     }
@@ -4991,7 +5125,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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);
@@ -5048,26 +5182,23 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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']);
             }
         }
     }
     else {
-        // Did we provide a custom serialization method
-        if (object.toBSON) {
-            if (typeof object.toBSON !== 'function')
-                throw new TypeError('toBSON is not a function');
+        if (typeof (object === null || object === void 0 ? void 0 : object.toBSON) === 'function') {
+            // Provided a custom serialization method
             object = object.toBSON();
-            if (object != null && typeof object !== 'object')
-                throw new TypeError('toBSON function did not return an object');
+            if (object != null && typeof object !== 'object') {
+                throw new BSONTypeError('toBSON function did not return an object');
+            }
         }
         // Iterate over all the keys
         for (var key in object) {
             var value = object[key];
             // Is there an override value
-            if (value && value.toBSON) {
-                if (typeof value.toBSON !== 'function')
-                    throw new TypeError('toBSON is not a function');
+            if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
                 value = value.toBSON();
             }
             // Check the type of the value
@@ -5095,7 +5226,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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);
@@ -5156,7 +5287,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                 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']);
             }
         }
     }
@@ -5329,9 +5460,11 @@ var BSON = {
     serializeWithBufferAndIndex: serializeWithBufferAndIndex,
     deserialize: deserialize,
     calculateObjectSize: calculateObjectSize,
-    deserializeStream: deserializeStream
+    deserializeStream: deserializeStream,
+    BSONError: BSONError,
+    BSONTypeError: BSONTypeError
 };
 
 export default BSON;
-export { BSONRegExp, BSONSymbol, BSON_BINARY_SUBTYPE_BYTE_ARRAY, BSON_BINARY_SUBTYPE_DEFAULT, BSON_BINARY_SUBTYPE_FUNCTION, BSON_BINARY_SUBTYPE_MD5, BSON_BINARY_SUBTYPE_USER_DEFINED, BSON_BINARY_SUBTYPE_UUID, BSON_BINARY_SUBTYPE_UUID_NEW, BSON_DATA_ARRAY, BSON_DATA_BINARY, BSON_DATA_BOOLEAN, BSON_DATA_CODE, BSON_DATA_CODE_W_SCOPE, BSON_DATA_DATE, BSON_DATA_DBPOINTER, BSON_DATA_DECIMAL128, BSON_DATA_INT, BSON_DATA_LONG, BSON_DATA_MAX_KEY, BSON_DATA_MIN_KEY, BSON_DATA_NULL, BSON_DATA_NUMBER, BSON_DATA_OBJECT, BSON_DATA_OID, BSON_DATA_REGEXP, BSON_DATA_STRING, BSON_DATA_SYMBOL, BSON_DATA_TIMESTAMP, BSON_DATA_UNDEFINED, BSON_INT32_MAX, BSON_INT32_MIN, BSON_INT64_MAX, BSON_INT64_MIN, Binary, Code, DBRef, Decimal128, Double, EJSON, Int32, Long, LongWithoutOverridesClass, bsonMap as Map, MaxKey, MinKey, ObjectId as ObjectID, ObjectId, Timestamp, UUID, calculateObjectSize, deserialize, deserializeStream, serialize, serializeWithBufferAndIndex, setInternalBufferSize };
+export { BSONError, BSONRegExp, BSONSymbol, BSONTypeError, BSON_BINARY_SUBTYPE_BYTE_ARRAY, BSON_BINARY_SUBTYPE_COLUMN, BSON_BINARY_SUBTYPE_DEFAULT, BSON_BINARY_SUBTYPE_ENCRYPTED, BSON_BINARY_SUBTYPE_FUNCTION, BSON_BINARY_SUBTYPE_MD5, BSON_BINARY_SUBTYPE_USER_DEFINED, BSON_BINARY_SUBTYPE_UUID, BSON_BINARY_SUBTYPE_UUID_NEW, BSON_DATA_ARRAY, BSON_DATA_BINARY, BSON_DATA_BOOLEAN, BSON_DATA_CODE, BSON_DATA_CODE_W_SCOPE, BSON_DATA_DATE, BSON_DATA_DBPOINTER, BSON_DATA_DECIMAL128, BSON_DATA_INT, BSON_DATA_LONG, BSON_DATA_MAX_KEY, BSON_DATA_MIN_KEY, BSON_DATA_NULL, BSON_DATA_NUMBER, BSON_DATA_OBJECT, BSON_DATA_OID, BSON_DATA_REGEXP, BSON_DATA_STRING, BSON_DATA_SYMBOL, BSON_DATA_TIMESTAMP, BSON_DATA_UNDEFINED, BSON_INT32_MAX, BSON_INT32_MIN, BSON_INT64_MAX, BSON_INT64_MIN, Binary, Code, DBRef, Decimal128, Double, EJSON, Int32, Long, LongWithoutOverridesClass, bsonMap as Map, MaxKey, MinKey, ObjectId as ObjectID, ObjectId, Timestamp, UUID, calculateObjectSize, deserialize, deserializeStream, serialize, serializeWithBufferAndIndex, setInternalBufferSize };
 //# sourceMappingURL=bson.esm.js.map