bson 5.4.0 → 6.0.0-alpha

package/README.md

@@ -4,6 +4,7 @@ BSON is short for "Binary JSON," and is the binary-encoded serialization of JSON
 You can learn more about it in [the specification](http://bsonspec.org).
 
 ### Table of Contents
+
 - [Usage](#usage)
 - [Bugs/Feature Requests](#bugs--feature-requests)
 - [Installation](#installation)
@@ -18,7 +19,7 @@ Think you've found a bug? Want to see a new feature in `bson`? Please open a cas
 2. Navigate to the NODE project: [jira.mongodb.org/browse/NODE](https://jira.mongodb.org/browse/NODE)
 3. Click **Create Issue** - Please provide as much information as possible about the issue and how to reproduce it.
 
-Bug reports in JIRA for all driver projects (i.e. NODE, PYTHON, CSHARP, JAVA) and the Core Server (i.e. SERVER) project are **public**.
+Bug reports in JIRA for the NODE driver project are **public**.
 
 ## Usage
 
@@ -67,9 +68,20 @@ If you are working directly in the browser without a bundler please use the `.mj
 npm install bson
 ```
 
+### MongoDB Node.js Driver Version Compatibility
+
+Only the following version combinations with the [MongoDB Node.js Driver](https://github.com/mongodb/node-mongodb-native) are considered stable.
+
+|               | `bson@1.x` | `bson@4.x` | `bson@5.x` | `bson@6.x` |
+| ------------- | ---------- | ---------- | ---------- | ---------- |
+| `mongodb@6.x` | N/A        | N/A        | N/A        | ✓          |
+| `mongodb@5.x` | N/A        | N/A        | ✓          | N/A        |
+| `mongodb@4.x` | N/A        | ✓          | N/A        | N/A        |
+| `mongodb@3.x` | ✓          | N/A        | N/A        | N/A        |
+
 ## Documentation
 
-### BSON 
+### BSON
 
 [API documentation](https://mongodb.github.io/node-mongodb-native/Next/modules/BSON.html)
 
@@ -77,31 +89,31 @@ npm install bson
 
 ### EJSON
 
-* [EJSON](#EJSON)
-
-    * [.parse(text, [options])](#EJSON.parse)
+- [EJSON](#EJSON)
 
-    * [.stringify(value, [replacer], [space], [options])](#EJSON.stringify)
+  - [.parse(text, [options])](#EJSON.parse)
 
-    * [.serialize(bson, [options])](#EJSON.serialize)
+  - [.stringify(value, [replacer], [space], [options])](#EJSON.stringify)
 
-    * [.deserialize(ejson, [options])](#EJSON.deserialize)
+  - [.serialize(bson, [options])](#EJSON.serialize)
 
+  - [.deserialize(ejson, [options])](#EJSON.deserialize)
 
 <a name="EJSON.parse"></a>
 
-#### *EJSON*.parse(text, [options])
+#### _EJSON_.parse(text, [options])
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| text | <code>string</code> |  |  |
-| [options] | <code>object</code> |  | Optional settings |
+| Param             | Type                 | Default           | Description                                                                        |
+| ----------------- | -------------------- | ----------------- | ---------------------------------------------------------------------------------- |
+| text              | <code>string</code>  |                   |                                                                                    |
+| [options]         | <code>object</code>  |                   | Optional settings                                                                  |
 | [options.relaxed] | <code>boolean</code> | <code>true</code> | Attempt to return native JS types where possible, rather than BSON types (if true) |
 
 Parse an Extended JSON string, constructing the JavaScript value or object described by that
 string.
 
 **Example**
+
 ```js
 const { EJSON } = require('bson');
 const text = '{ "int32": { "$numberInt": "10" } }';
@@ -112,24 +124,26 @@ console.log(EJSON.parse(text, { relaxed: false }));
 // prints { int32: 10 }
 console.log(EJSON.parse(text));
 ```
+
 <a name="EJSON.stringify"></a>
 
-#### *EJSON*.stringify(value, [replacer], [space], [options])
+#### _EJSON_.stringify(value, [replacer], [space], [options])
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| value | <code>object</code> |  | The value to convert to extended JSON |
-| [replacer] | <code>function</code> \| <code>array</code> |  | A function that alters the behavior of the stringification process, or an array of String and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string |
-| [space] | <code>string</code> \| <code>number</code> |  | A String or Number object that's used to insert white space into the output JSON string for readability purposes. |
-| [options] | <code>object</code> |  | Optional settings |
-| [options.relaxed] | <code>boolean</code> | <code>true</code> | Enabled Extended JSON's `relaxed` mode |
-| [options.legacy] | <code>boolean</code> | <code>true</code> | Output in Extended JSON v1 |
+| Param             | Type                                        | Default           | Description                                                                                                                                                                                                                                                                                                                                        |
+| ----------------- | ------------------------------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| value             | <code>object</code>                         |                   | The value to convert to extended JSON                                                                                                                                                                                                                                                                                                              |
+| [replacer]        | <code>function</code> \| <code>array</code> |                   | A function that alters the behavior of the stringification process, or an array of String and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string |
+| [space]           | <code>string</code> \| <code>number</code>  |                   | A String or Number object that's used to insert white space into the output JSON string for readability purposes.                                                                                                                                                                                                                                  |
+| [options]         | <code>object</code>                         |                   | Optional settings                                                                                                                                                                                                                                                                                                                                  |
+| [options.relaxed] | <code>boolean</code>                        | <code>true</code> | Enabled Extended JSON's `relaxed` mode                                                                                                                                                                                                                                                                                                             |
+| [options.legacy]  | <code>boolean</code>                        | <code>true</code> | Output in Extended JSON v1                                                                                                                                                                                                                                                                                                                         |
 
 Converts a BSON document to an Extended JSON string, optionally replacing values if a replacer
 function is specified or optionally including only the specified properties if a replacer array
 is specified.
 
 **Example**
+
 ```js
 const { EJSON } = require('bson');
 const Int32 = require('mongodb').Int32;
@@ -141,24 +155,25 @@ console.log(EJSON.stringify(doc, { relaxed: false }));
 // prints '{"int32":10}'
 console.log(EJSON.stringify(doc));
 ```
+
 <a name="EJSON.serialize"></a>
 
-#### *EJSON*.serialize(bson, [options])
+#### _EJSON_.serialize(bson, [options])
 
-| Param | Type | Description |
-| --- | --- | --- |
-| bson | <code>object</code> | The object to serialize |
+| Param     | Type                | Description                                          |
+| --------- | ------------------- | ---------------------------------------------------- |
+| bson      | <code>object</code> | The object to serialize                              |
 | [options] | <code>object</code> | Optional settings passed to the `stringify` function |
 
 Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.
 
 <a name="EJSON.deserialize"></a>
 
-#### *EJSON*.deserialize(ejson, [options])
+#### _EJSON_.deserialize(ejson, [options])
 
-| Param | Type | Description |
-| --- | --- | --- |
-| ejson | <code>object</code> | The Extended JSON object to deserialize |
+| Param     | Type                | Description                                  |
+| --------- | ------------------- | -------------------------------------------- |
+| ejson     | <code>object</code> | The Extended JSON object to deserialize      |
 | [options] | <code>object</code> | Optional settings passed to the parse method |
 
 Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types
@@ -194,7 +209,7 @@ BSON vendors the required polyfills for `TextEncoder`, `TextDecoder`, `atob`, `b
 npm install --save react-native-get-random-values
 ```
 
-The following snippet should be placed at the top of the entrypoint (by default this is the root `index.js` file) for React Native projects using the BSON library.  These lines must be placed for any code that imports `BSON`.
+The following snippet should be placed at the top of the entrypoint (by default this is the root `index.js` file) for React Native projects using the BSON library. These lines must be placed for any code that imports `BSON`.
 
 ```typescript
 // Required Polyfills For ReactNative
@@ -211,7 +226,7 @@ This will cause React Native to import the `node_modules/bson/lib/bson.rn.cjs` b
 
 ### Technical Note about React Native module import
 
-The `"exports"` definition in our `package.json` will result in BSON's CommonJS bundle being imported in a React Native project instead of the ES module bundle.  Importing the CommonJS bundle is necessary because BSON's ES module bundle of BSON uses top-level await, which is not supported syntax in [React Native's runtime hermes](https://hermesengine.dev/).
+The `"exports"` definition in our `package.json` will result in BSON's CommonJS bundle being imported in a React Native project instead of the ES module bundle. Importing the CommonJS bundle is necessary because BSON's ES module bundle of BSON uses top-level await, which is not supported syntax in [React Native's runtime hermes](https://hermesengine.dev/).
 
 ## FAQ
 

package/bson.d.ts

@@ -31,16 +31,10 @@ export declare class Binary extends BSONValue {
     position: number;
     /**
      * Create a new Binary instance.
-     *
-     * This constructor can accept a string as its first argument. In this case,
-     * this string will be encoded using ISO-8859-1, **not** using UTF-8.
-     * This is almost certainly not what you want. Use `new Binary(Buffer.from(string))`
-     * instead to convert the string to a Buffer using UTF-8 first.
-     *
      * @param buffer - a buffer object containing the binary data.
      * @param subType - the option binary type.
      */
-    constructor(buffer?: string | BinarySequence, subType?: number);
+    constructor(buffer?: BinarySequence, subType?: number);
     /**
      * Updates this binary with byte_value.
      *
@@ -48,12 +42,12 @@ export declare class Binary extends BSONValue {
      */
     put(byteValue: string | number | Uint8Array | number[]): void;
     /**
-     * Writes a buffer or string to the binary.
+     * Writes a buffer to the binary.
      *
      * @param sequence - a string or buffer to be written to the Binary BSON object.
      * @param offset - specify the binary of where to write the content.
      */
-    write(sequence: string | BinarySequence, offset: number): void;
+    write(sequence: BinarySequence, offset: number): void;
     /**
      * Reads **length** bytes starting at **position**.
      *
@@ -61,13 +55,8 @@ export declare class Binary extends BSONValue {
      * @param length - the number of bytes to read.
      */
     read(position: number, length: number): BinarySequence;
-    /**
-     * Returns the value of this binary as a string.
-     * @param asRaw - Will skip converting to a string
-     * @remarks
-     * This is handy when calling this function conditionally for some key value pairs and not others
-     */
-    value(asRaw?: boolean): string | BinarySequence;
+    /** returns a view of the binary value as a Uint8Array */
+    value(): Uint8Array;
     /** the length of the binary sequence */
     length(): number;
     toJSON(): string;
@@ -990,7 +979,7 @@ export declare class ObjectId extends BSONValue {
      */
     get id(): Uint8Array;
     set id(value: Uint8Array);
-    /** Returns the ObjectId id as a 24 character hex string representation */
+    /** Returns the ObjectId id as a 24 lowercase character hex string representation */
     toHexString(): string;
     /* Excluded from this release type: getInc */
     /**
@@ -1006,12 +995,13 @@ export declare class ObjectId extends BSONValue {
     toString(encoding?: 'hex' | 'base64'): string;
     /** Converts to its JSON the 24 character hex string representation. */
     toJSON(): string;
+    /* Excluded from this release type: is */
     /**
      * Compares the equality of this ObjectId with `otherID`.
      *
      * @param otherId - ObjectId instance to compare against.
      */
-    equals(otherId: string | ObjectId | ObjectIdLike): boolean;
+    equals(otherId: string | ObjectId | ObjectIdLike | undefined | null): boolean;
     /** Returns the generation date (accurate up to the second) that this ID was generated. */
     getTimestamp(): Date;
     /* Excluded from this release type: createPk */
@@ -1030,9 +1020,8 @@ export declare class ObjectId extends BSONValue {
     /** Creates an ObjectId instance from a base64 string */
     static createFromBase64(base64: string): ObjectId;
     /**
-     * Checks if a value is a valid bson ObjectId
-     *
-     * @param id - ObjectId instance to validate.
+     * Checks if a value can be used to create a valid bson ObjectId
+     * @param id - any JS value
      */
     static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean;
     /* Excluded from this release type: toExtendedJSON */
@@ -1213,8 +1202,6 @@ export declare type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromE
  * @public
  */
 export declare class UUID extends Binary {
-    /** @deprecated Hex string is no longer cached, this control will be removed in a future major release */
-    static cacheHexString: boolean;
     /**
      * Create a UUID type
      *

package/lib/bson.bundle.js

@@ -17,7 +17,7 @@ function isDate(d) {
     return Object.prototype.toString.call(d) === '[object Date]';
 }
 
-const BSON_MAJOR_VERSION = 5;
+const BSON_MAJOR_VERSION = 6;
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
 const BSON_INT64_MAX = Math.pow(2, 63) - 1;
@@ -312,11 +312,11 @@ class Binary extends BSONValue {
     constructor(buffer, subType) {
         super();
         if (!(buffer == null) &&
-            !(typeof buffer === 'string') &&
+            typeof buffer === 'string' &&
             !ArrayBuffer.isView(buffer) &&
-            !(buffer instanceof ArrayBuffer) &&
+            !isAnyArrayBuffer(buffer) &&
             !Array.isArray(buffer)) {
-            throw new BSONError('Binary can only be constructed from string, Buffer, TypedArray, or Array<number>');
+            throw new BSONError('Binary can only be constructed from Uint8Array or number[]');
         }
         this.sub_type = subType ?? Binary.BSON_BINARY_SUBTYPE_DEFAULT;
         if (buffer == null) {
@@ -324,15 +324,9 @@ class Binary extends BSONValue {
             this.position = 0;
         }
         else {
-            if (typeof buffer === 'string') {
-                this.buffer = ByteUtils.fromISO88591(buffer);
-            }
-            else if (Array.isArray(buffer)) {
-                this.buffer = ByteUtils.fromNumberArray(buffer);
-            }
-            else {
-                this.buffer = ByteUtils.toLocalBufferType(buffer);
-            }
+            this.buffer = Array.isArray(buffer)
+                ? ByteUtils.fromNumberArray(buffer)
+                : ByteUtils.toLocalBufferType(buffer);
             this.position = this.buffer.byteLength;
         }
     }
@@ -378,25 +372,17 @@ class Binary extends BSONValue {
                 offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;
         }
         else if (typeof sequence === 'string') {
-            const bytes = ByteUtils.fromISO88591(sequence);
-            this.buffer.set(bytes, offset);
-            this.position =
-                offset + sequence.length > this.position ? offset + sequence.length : this.position;
+            throw new BSONError('input cannot be string');
         }
     }
     read(position, length) {
         length = length && length > 0 ? length : this.position;
         return this.buffer.slice(position, position + length);
     }
-    value(asRaw) {
-        asRaw = !!asRaw;
-        if (asRaw && this.buffer.length === this.position) {
-            return this.buffer;
-        }
-        if (asRaw) {
-            return this.buffer.slice(0, this.position);
-        }
-        return ByteUtils.toISO88591(this.buffer.subarray(0, this.position));
+    value() {
+        return this.buffer.length === this.position
+            ? this.buffer
+            : this.buffer.subarray(0, this.position);
     }
     length() {
         return this.position;
@@ -597,7 +583,6 @@ class UUID extends Binary {
         return `new UUID("${this.toHexString()}")`;
     }
 }
-UUID.cacheHexString = false;
 
 class Code extends BSONValue {
     get _bsontype() {
@@ -628,7 +613,7 @@ class Code extends BSONValue {
     }
     inspect() {
         const codeJson = this.toJSON();
-        return `new Code("${String(codeJson.code)}"${codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''})`;
+        return `new Code(${JSON.stringify(String(codeJson.code))}${codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''})`;
     }
 }
 
@@ -1438,6 +1423,7 @@ class Decimal128 extends BSONValue {
     }
     static fromString(representation) {
         let isNegative = false;
+        let sawSign = false;
         let sawRadix = false;
         let foundNonZero = false;
         let significantDigits = 0;
@@ -1448,10 +1434,8 @@ class Decimal128 extends BSONValue {
         const digits = [0];
         let nDigitsStored = 0;
         let digitsInsert = 0;
-        let firstDigit = 0;
         let lastDigit = 0;
         let exponent = 0;
-        let i = 0;
         let significandHigh = new Long(0, 0);
         let significandLow = new Long(0, 0);
         let biasedExponent = 0;
@@ -1479,6 +1463,7 @@ class Decimal128 extends BSONValue {
             }
         }
         if (representation[index] === '+' || representation[index] === '-') {
+            sawSign = true;
             isNegative = representation[index++] === '-';
         }
         if (!isDigit(representation[index]) && representation[index] !== '.') {
@@ -1497,7 +1482,7 @@ class Decimal128 extends BSONValue {
                 index = index + 1;
                 continue;
             }
-            if (nDigitsStored < 34) {
+            if (nDigitsStored < MAX_DIGITS) {
                 if (representation[index] !== '0' || foundNonZero) {
                     if (!foundNonZero) {
                         firstNonZero = nDigitsRead;
@@ -1525,10 +1510,7 @@ class Decimal128 extends BSONValue {
         }
         if (representation[index])
             return new Decimal128(NAN_BUFFER);
-        firstDigit = 0;
         if (!nDigitsStored) {
-            firstDigit = 0;
-            lastDigit = 0;
             digits[0] = 0;
             nDigits = 1;
             nDigitsStored = 1;
@@ -1538,12 +1520,12 @@ class Decimal128 extends BSONValue {
             lastDigit = nDigitsStored - 1;
             significantDigits = nDigits;
             if (significantDigits !== 1) {
-                while (digits[firstNonZero + significantDigits - 1] === 0) {
+                while (representation[firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)] === '0') {
                     significantDigits = significantDigits - 1;
                 }
             }
         }
-        if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {
+        if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) {
             exponent = EXPONENT_MIN;
         }
         else {
@@ -1551,9 +1533,8 @@ class Decimal128 extends BSONValue {
         }
         while (exponent > EXPONENT_MAX) {
             lastDigit = lastDigit + 1;
-            if (lastDigit - firstDigit > MAX_DIGITS) {
-                const digitsString = digits.join('');
-                if (digitsString.match(/^0+$/)) {
+            if (lastDigit >= MAX_DIGITS) {
+                if (significantDigits === 0) {
                     exponent = EXPONENT_MAX;
                     break;
                 }
@@ -1562,69 +1543,43 @@ class Decimal128 extends BSONValue {
             exponent = exponent - 1;
         }
         while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
-            if (lastDigit === 0 && significantDigits < nDigitsStored) {
-                exponent = EXPONENT_MIN;
-                significantDigits = 0;
-                break;
+            if (lastDigit === 0) {
+                if (significantDigits === 0) {
+                    exponent = EXPONENT_MIN;
+                    break;
+                }
+                invalidErr(representation, 'exponent underflow');
             }
             if (nDigitsStored < nDigits) {
+                if (representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== '0' &&
+                    significantDigits !== 0) {
+                    invalidErr(representation, 'inexact rounding');
+                }
                 nDigits = nDigits - 1;
             }
             else {
+                if (digits[lastDigit] !== 0) {
+                    invalidErr(representation, 'inexact rounding');
+                }
                 lastDigit = lastDigit - 1;
             }
             if (exponent < EXPONENT_MAX) {
                 exponent = exponent + 1;
             }
             else {
-                const digitsString = digits.join('');
-                if (digitsString.match(/^0+$/)) {
-                    exponent = EXPONENT_MAX;
-                    break;
-                }
                 invalidErr(representation, 'overflow');
             }
         }
-        if (lastDigit - firstDigit + 1 < significantDigits) {
-            let endOfString = nDigitsRead;
+        if (lastDigit + 1 < significantDigits) {
             if (sawRadix) {
                 firstNonZero = firstNonZero + 1;
-                endOfString = endOfString + 1;
             }
-            if (isNegative) {
+            if (sawSign) {
                 firstNonZero = firstNonZero + 1;
-                endOfString = endOfString + 1;
             }
             const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
-            let roundBit = 0;
-            if (roundDigit >= 5) {
-                roundBit = 1;
-                if (roundDigit === 5) {
-                    roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;
-                    for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
-                        if (parseInt(representation[i], 10)) {
-                            roundBit = 1;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (roundBit) {
-                let dIdx = lastDigit;
-                for (; dIdx >= 0; dIdx--) {
-                    if (++digits[dIdx] > 9) {
-                        digits[dIdx] = 0;
-                        if (dIdx === 0) {
-                            if (exponent < EXPONENT_MAX) {
-                                exponent = exponent + 1;
-                                digits[dIdx] = 1;
-                            }
-                            else {
-                                return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
-                            }
-                        }
-                    }
-                }
+            if (roundDigit !== 0) {
+                invalidErr(representation, 'inexact rounding');
             }
         }
         significandHigh = Long.fromNumber(0);
@@ -1633,8 +1588,8 @@ class Decimal128 extends BSONValue {
             significandHigh = Long.fromNumber(0);
             significandLow = Long.fromNumber(0);
         }
-        else if (lastDigit - firstDigit < 17) {
-            let dIdx = firstDigit;
+        else if (lastDigit < 17) {
+            let dIdx = 0;
             significandLow = Long.fromNumber(digits[dIdx++]);
             significandHigh = new Long(0, 0);
             for (; dIdx <= lastDigit; dIdx++) {
@@ -1643,7 +1598,7 @@ class Decimal128 extends BSONValue {
             }
         }
         else {
-            let dIdx = firstDigit;
+            let dIdx = 0;
             significandHigh = Long.fromNumber(digits[dIdx++]);
             for (; dIdx <= lastDigit - 17; dIdx++) {
                 significandHigh = significandHigh.multiply(Long.fromNumber(10));
@@ -1991,20 +1946,11 @@ class ObjectId extends BSONValue {
             this[kId] = ByteUtils.toLocalBufferType(workingId);
         }
         else if (typeof workingId === 'string') {
-            if (workingId.length === 12) {
-                const bytes = ByteUtils.fromUTF8(workingId);
-                if (bytes.byteLength === 12) {
-                    this[kId] = bytes;
-                }
-                else {
-                    throw new BSONError('Argument passed in must be a string of 12 bytes');
-                }
-            }
-            else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+            if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
                 this[kId] = ByteUtils.fromHex(workingId);
             }
             else {
-                throw new BSONError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer');
+                throw new BSONError('input must be a 24 character hex string, 12 byte Uint8Array, or an integer');
             }
         }
         else {
@@ -2066,30 +2012,25 @@ class ObjectId extends BSONValue {
     toJSON() {
         return this.toHexString();
     }
+    static is(variable) {
+        return (variable != null &&
+            typeof variable === 'object' &&
+            '_bsontype' in variable &&
+            variable._bsontype === 'ObjectId');
+    }
     equals(otherId) {
         if (otherId === undefined || otherId === null) {
             return false;
         }
-        if (otherId instanceof ObjectId) {
+        if (ObjectId.is(otherId)) {
             return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);
         }
-        if (typeof otherId === 'string' &&
-            ObjectId.isValid(otherId) &&
-            otherId.length === 12 &&
-            isUint8Array(this.id)) {
-            return ByteUtils.equals(this.id, ByteUtils.fromISO88591(otherId));
-        }
-        if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {
+        if (typeof otherId === 'string') {
             return otherId.toLowerCase() === this.toHexString();
         }
-        if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12) {
-            return ByteUtils.equals(ByteUtils.fromUTF8(otherId), this.id);
-        }
-        if (typeof otherId === 'object' &&
-            'toHexString' in otherId &&
-            typeof otherId.toHexString === 'function') {
+        if (typeof otherId === 'object' && typeof otherId.toHexString === 'function') {
             const otherIdString = otherId.toHexString();
-            const thisIdString = this.toHexString().toLowerCase();
+            const thisIdString = this.toHexString();
             return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;
         }
         return false;
@@ -2379,7 +2320,7 @@ class BSONSymbol extends BSONValue {
         return this.value;
     }
     inspect() {
-        return `new BSONSymbol("${this.value}")`;
+        return `new BSONSymbol(${JSON.stringify(this.value)})`;
     }
     toJSON() {
         return this.value;