bson 5.0.0-alpha.2 → 5.0.0

package/package.json

@@ -13,7 +13,7 @@
     "etc/prepare.js"
   ],
   "types": "bson.d.ts",
-  "version": "5.0.0-alpha.2",
+  "version": "5.0.0",
   "author": {
     "name": "The MongoDB NodeJS Team",
     "email": "dbx-node@mongodb.com"

package/src/binary.ts

@@ -2,8 +2,9 @@ import { bufferToUuidHexString, uuidHexStringToBuffer, uuidValidateString } from
 import { isUint8Array } from './parser/utils';
 import type { EJSONOptions } from './extended_json';
 import { BSONError } from './error';
-import { BSON_BINARY_SUBTYPE_UUID_NEW, BSON_MAJOR_VERSION } from './constants';
+import { BSON_BINARY_SUBTYPE_UUID_NEW } from './constants';
 import { ByteUtils } from './utils/byte_utils';
+import { BSONValue } from './bson_value';
 
 /** @public */
 export type BinarySequence = Uint8Array | number[];
@@ -27,14 +28,10 @@ export interface BinaryExtended {
  * @public
  * @category BSONType
  */
-export class Binary {
+export class Binary extends BSONValue {
   get _bsontype(): 'Binary' {
     return 'Binary';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /**
    * Binary default subtype
@@ -79,6 +76,7 @@ export class Binary {
    * @param subType - the option binary type.
    */
   constructor(buffer?: string | BinarySequence, subType?: number) {
+    super();
     if (
       !(buffer == null) &&
       !(typeof buffer === 'string') &&
@@ -309,11 +307,6 @@ const UUID_BYTE_LENGTH = 16;
  * @public
  */
 export class UUID extends Binary {
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
-
   static cacheHexString: boolean;
 
   /** UUID hexString cache @internal */

package/src/bson.ts

@@ -49,7 +49,8 @@ export {
   BSONRegExp,
   Decimal128
 };
-export { BSONError } from './error';
+export { BSONValue } from './bson_value';
+export { BSONError, BSONVersionError } from './error';
 export { BSONType } from './constants';
 export { EJSON } from './extended_json';
 

package/src/bson_value.ts

@@ -0,0 +1,18 @@
+import { BSON_MAJOR_VERSION } from './constants';
+
+/** @public */
+export abstract class BSONValue {
+  /** @public */
+  public abstract get _bsontype(): string;
+
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): typeof BSON_MAJOR_VERSION {
+    return BSON_MAJOR_VERSION;
+  }
+
+  /** @public */
+  public abstract inspect(): string;
+
+  /** @internal */
+  abstract toExtendedJSON(): unknown;
+}

package/src/code.ts

@@ -1,5 +1,5 @@
 import type { Document } from './bson';
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 
 /** @public */
 export interface CodeExtended {
@@ -12,14 +12,10 @@ export interface CodeExtended {
  * @public
  * @category BSONType
  */
-export class Code {
+export class Code extends BSONValue {
   get _bsontype(): 'Code' {
     return 'Code';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   code: string;
 
@@ -32,6 +28,7 @@ export class Code {
    * @param scope - an optional scope for the function.
    */
   constructor(code: string | Function, scope?: Document | null) {
+    super();
     this.code = code.toString();
     this.scope = scope ?? null;
   }

package/src/constants.ts

@@ -1,7 +1,5 @@
 /** @internal */
-export type BSON_MAJOR_VERSION = 5;
-/** @internal */
-export const BSON_MAJOR_VERSION: BSON_MAJOR_VERSION = 5;
+export const BSON_MAJOR_VERSION = 5 as const;
 
 /** @internal */
 export const BSON_INT32_MAX = 0x7fffffff;

package/src/db_ref.ts

@@ -1,5 +1,5 @@
 import type { Document } from './bson';
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import type { EJSONOptions } from './extended_json';
 import type { ObjectId } from './objectid';
 
@@ -29,14 +29,10 @@ export function isDBRefLike(value: unknown): value is DBRefLike {
  * @public
  * @category BSONType
  */
-export class DBRef {
+export class DBRef extends BSONValue {
   get _bsontype(): 'DBRef' {
     return 'DBRef';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   collection!: string;
   oid!: ObjectId;
@@ -49,6 +45,7 @@ export class DBRef {
    * @param db - optional db name, if omitted the reference is local to the current db.
    */
   constructor(collection: string, oid: ObjectId, db?: string, fields?: Document) {
+    super();
     // check if namespace has been provided
     const parts = collection.split('.');
     if (parts.length === 2) {

package/src/decimal128.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import { BSONError } from './error';
 import { Long } from './long';
 import { isUint8Array } from './parser/utils';
@@ -127,14 +127,10 @@ export interface Decimal128Extended {
  * @public
  * @category BSONType
  */
-export class Decimal128 {
+export class Decimal128 extends BSONValue {
   get _bsontype(): 'Decimal128' {
     return 'Decimal128';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   readonly bytes!: Uint8Array;
 
@@ -143,6 +139,7 @@ export class Decimal128 {
    *                or a string representation as returned by .toString()
    */
   constructor(bytes: Uint8Array | string) {
+    super();
     if (typeof bytes === 'string') {
       this.bytes = Decimal128.fromString(bytes).bytes;
     } else if (isUint8Array(bytes)) {

package/src/double.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import type { EJSONOptions } from './extended_json';
 
 /** @public */
@@ -11,14 +11,10 @@ export interface DoubleExtended {
  * @public
  * @category BSONType
  */
-export class Double {
+export class Double extends BSONValue {
   get _bsontype(): 'Double' {
     return 'Double';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   value!: number;
   /**
@@ -27,6 +23,7 @@ export class Double {
    * @param value - the number we want to represent as a double.
    */
   constructor(value: number) {
+    super();
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }

package/src/error.ts

@@ -1,3 +1,5 @@
+import { BSON_MAJOR_VERSION } from './constants';
+
 /**
  * @public
  * `BSONError` objects are thrown when runtime errors occur.
@@ -43,3 +45,16 @@ export class BSONError extends Error {
     );
   }
 }
+
+/** @public */
+export class BSONVersionError extends BSONError {
+  get name(): 'BSONVersionError' {
+    return 'BSONVersionError';
+  }
+
+  constructor() {
+    super(
+      `Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.0 or later`
+    );
+  }
+}

package/src/extended_json.ts

@@ -11,7 +11,7 @@ import {
 import { DBRef, isDBRefLike } from './db_ref';
 import { Decimal128 } from './decimal128';
 import { Double } from './double';
-import { BSONError } from './error';
+import { BSONError, BSONVersionError } from './error';
 import { Int32 } from './int_32';
 import { Long } from './long';
 import { MaxKey } from './max_key';
@@ -28,6 +28,8 @@ export type EJSONOptions = {
   legacy?: boolean;
   /** Enable Extended JSON's `relaxed` mode, which attempts to return native JS types where possible, rather than BSON types */
   relaxed?: boolean;
+  /** Enable native bigint support */
+  useBigInt64?: boolean;
 };
 
 /** @internal */
@@ -76,17 +78,23 @@ const keysToCodecs = {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function deserializeValue(value: any, options: EJSONOptions = {}) {
   if (typeof value === 'number') {
+    // TODO(NODE-4377): EJSON js number handling diverges from BSON
+    const in32BitRange = value <= BSON_INT32_MAX && value >= BSON_INT32_MIN;
+    const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN;
+
     if (options.relaxed || options.legacy) {
       return value;
     }
 
     if (Number.isInteger(value) && !Object.is(value, -0)) {
       // interpret as being of the smallest BSON integer type that can represent the number exactly
-      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
+      if (in32BitRange) {
         return new Int32(value);
       }
-      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {
-        // TODO(NODE-4377): EJSON js number handling diverges from BSON
+      if (in64BitRange) {
+        if (options.useBigInt64) {
+          return BigInt(value);
+        }
         return Long.fromNumber(value);
       }
     }
@@ -240,6 +248,13 @@ function serializeValue(value: any, options: EJSONSerializeOptions): any {
     return { $numberDouble: Object.is(value, -0) ? '-0.0' : value.toString() };
   }
 
+  if (typeof value === 'bigint') {
+    if (!options.relaxed) {
+      return { $numberLong: BigInt.asIntN(64, value).toString() };
+    }
+    return Number(BigInt.asIntN(64, value));
+  }
+
   if (value instanceof RegExp || isRegExp(value)) {
     let flags = value.flags;
     if (flags === undefined) {
@@ -318,7 +333,7 @@ function serializeDocument(doc: any, options: EJSONSerializeOptions) {
     typeof doc._bsontype === 'string' &&
     doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION
   ) {
-    throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+    throw new BSONVersionError();
   } else if (isBSONType(doc)) {
     // the "document" is really just a BSON type object
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -371,13 +386,18 @@ function serializeDocument(doc: any, options: EJSONSerializeOptions) {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function parse(text: string, options?: EJSONOptions): any {
+  const ejsonOptions = {
+    useBigInt64: options?.useBigInt64 ?? false,
+    relaxed: options?.relaxed ?? true,
+    legacy: options?.legacy ?? false
+  };
   return JSON.parse(text, (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, { relaxed: true, legacy: false, ...options });
+    return deserializeValue(value, ejsonOptions);
   });
 }
 

package/src/int_32.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import type { EJSONOptions } from './extended_json';
 
 /** @public */
@@ -11,14 +11,10 @@ export interface Int32Extended {
  * @public
  * @category BSONType
  */
-export class Int32 {
+export class Int32 extends BSONValue {
   get _bsontype(): 'Int32' {
     return 'Int32';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   value!: number;
   /**
@@ -27,6 +23,7 @@ export class Int32 {
    * @param value - the number we want to represent as an int32.
    */
   constructor(value: number | string) {
+    super();
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }

package/src/long.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import { BSONError } from './error';
 import type { EJSONOptions } from './extended_json';
 import type { Timestamp } from './timestamp';
@@ -76,6 +76,10 @@ const INT_CACHE: { [key: number]: Long } = {};
 /** A cache of the Long representations of small unsigned integer values. */
 const UINT_CACHE: { [key: number]: Long } = {};
 
+const MAX_INT64_STRING_LENGTH = 20;
+
+const DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/;
+
 /** @public */
 export interface LongExtended {
   $numberLong: string;
@@ -100,14 +104,10 @@ export interface LongExtended {
  * case would often result in infinite recursion.
  * Common constant values ZERO, ONE, NEG_ONE, etc. are found as static properties on this class.
  */
-export class Long {
+export class Long extends BSONValue {
   get _bsontype(): 'Long' {
     return 'Long';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** An indicator used to reliably determine if an object is a Long or not. */
   get __isLong__(): boolean {
@@ -143,6 +143,7 @@ export class Long {
    * @param unsigned - Whether unsigned or not, defaults to signed
    */
   constructor(low: number | bigint | string = 0, high?: number | boolean, unsigned?: boolean) {
+    super();
     if (typeof low === 'bigint') {
       Object.assign(this, Long.fromBigInt(low, !!high));
     } else if (typeof low === 'string') {
@@ -1026,9 +1027,30 @@ export class Long {
     if (options && options.relaxed) return this.toNumber();
     return { $numberLong: this.toString() };
   }
-  static fromExtendedJSON(doc: { $numberLong: string }, options?: EJSONOptions): number | Long {
-    const result = Long.fromString(doc.$numberLong);
-    return options && options.relaxed ? result.toNumber() : result;
+  static fromExtendedJSON(
+    doc: { $numberLong: string },
+    options?: EJSONOptions
+  ): number | Long | bigint {
+    const { useBigInt64 = false, relaxed = true } = { ...options };
+
+    if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) {
+      throw new BSONError('$numberLong string is too long');
+    }
+
+    if (!DECIMAL_REG_EX.test(doc.$numberLong)) {
+      throw new BSONError(`$numberLong string "${doc.$numberLong}" is in an invalid format`);
+    }
+
+    if (useBigInt64) {
+      const bigIntResult = BigInt(doc.$numberLong);
+      return BigInt.asIntN(64, bigIntResult);
+    }
+
+    const longResult = Long.fromString(doc.$numberLong);
+    if (relaxed) {
+      return longResult.toNumber();
+    }
+    return longResult;
   }
 
   /** @internal */

package/src/max_key.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 
 /** @public */
 export interface MaxKeyExtended {
@@ -10,14 +10,10 @@ export interface MaxKeyExtended {
  * @public
  * @category BSONType
  */
-export class MaxKey {
+export class MaxKey extends BSONValue {
   get _bsontype(): 'MaxKey' {
     return 'MaxKey';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** @internal */
   toExtendedJSON(): MaxKeyExtended {

package/src/min_key.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 
 /** @public */
 export interface MinKeyExtended {
@@ -10,14 +10,10 @@ export interface MinKeyExtended {
  * @public
  * @category BSONType
  */
-export class MinKey {
+export class MinKey extends BSONValue {
   get _bsontype(): 'MinKey' {
     return 'MinKey';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** @internal */
   toExtendedJSON(): MinKeyExtended {

package/src/objectid.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import { BSONError } from './error';
 import { isUint8Array } from './parser/utils';
 import { BSONDataView, ByteUtils } from './utils/byte_utils';
@@ -28,14 +28,10 @@ const kId = Symbol('id');
  * @public
  * @category BSONType
  */
-export class ObjectId {
+export class ObjectId extends BSONValue {
   get _bsontype(): 'ObjectId' {
     return 'ObjectId';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** @internal */
   private static index = Math.floor(Math.random() * 0xffffff);
@@ -53,6 +49,7 @@ export class ObjectId {
    * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
    */
   constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array) {
+    super();
     // workingId is set based on type of input and whether valid id exists for the input
     let workingId;
     if (typeof inputId === 'object' && inputId && 'id' in inputId) {

package/src/parser/calculate_size.ts

@@ -1,6 +1,6 @@
 import { Binary } from '../binary';
 import type { Document } from '../bson';
-import { BSONError } from '../error';
+import { BSONVersionError } from '../error';
 import * as constants from '../constants';
 import { ByteUtils } from '../utils/byte_utils';
 import { isAnyArrayBuffer, isDate, isRegExp } from './utils';
@@ -83,14 +83,10 @@ function calculateElement(
         typeof value._bsontype === 'string' &&
         value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
       ) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
-      } else if (
-        value == null ||
-        value['_bsontype'] === 'MinKey' ||
-        value['_bsontype'] === 'MaxKey'
-      ) {
+        throw new BSONVersionError();
+      } else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;
-      } else if (value['_bsontype'] === 'ObjectId') {
+      } else if (value._bsontype === 'ObjectId') {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (12 + 1);
       } else if (value instanceof Date || isDate(value)) {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
@@ -103,14 +99,14 @@ function calculateElement(
           (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 4 + 1) + value.byteLength
         );
       } else if (
-        value['_bsontype'] === 'Long' ||
-        value['_bsontype'] === 'Double' ||
-        value['_bsontype'] === 'Timestamp'
+        value._bsontype === 'Long' ||
+        value._bsontype === 'Double' ||
+        value._bsontype === 'Timestamp'
       ) {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
-      } else if (value['_bsontype'] === 'Decimal128') {
+      } else if (value._bsontype === 'Decimal128') {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (16 + 1);
-      } else if (value['_bsontype'] === 'Code') {
+      } else if (value._bsontype === 'Code') {
         // Calculate size depending on the availability of a scope
         if (value.scope != null && Object.keys(value.scope).length > 0) {
           return (
@@ -131,7 +127,7 @@ function calculateElement(
             1
           );
         }
-      } else if (value['_bsontype'] === 'Binary') {
+      } else if (value._bsontype === 'Binary') {
         const binary: Binary = value;
         // Check what kind of subtype we have
         if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
@@ -144,7 +140,7 @@ function calculateElement(
             (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1)
           );
         }
-      } else if (value['_bsontype'] === 'Symbol') {
+      } else if (value._bsontype === 'Symbol') {
         return (
           (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
           ByteUtils.utf8ByteLength(value.value) +
@@ -152,7 +148,7 @@ function calculateElement(
           1 +
           1
         );
-      } else if (value['_bsontype'] === 'DBRef') {
+      } else if (value._bsontype === 'DBRef') {
         // Set up correct object for serialization
         const ordered_values = Object.assign(
           {
@@ -183,7 +179,7 @@ function calculateElement(
           (value.multiline ? 1 : 0) +
           1
         );
-      } else if (value['_bsontype'] === 'BSONRegExp') {
+      } else if (value._bsontype === 'BSONRegExp') {
         return (
           (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
           1 +

package/src/parser/serializer.ts

@@ -5,7 +5,7 @@ import * as constants from '../constants';
 import type { DBRefLike } from '../db_ref';
 import type { Decimal128 } from '../decimal128';
 import type { Double } from '../double';
-import { BSONError } from '../error';
+import { BSONError, BSONVersionError } from '../error';
 import type { Int32 } from '../int_32';
 import { Long } from '../long';
 import type { MinKey } from '../min_key';
@@ -710,7 +710,7 @@ export function serializeInto(
         typeof value === 'object' &&
         value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
       ) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+        throw new BSONVersionError();
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
       } else if (value._bsontype === 'Decimal128') {
@@ -820,7 +820,7 @@ export function serializeInto(
         typeof value === 'object' &&
         value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
       ) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+        throw new BSONVersionError();
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
       } else if (type === 'object' && value._bsontype === 'Decimal128') {
@@ -930,7 +930,7 @@ export function serializeInto(
         typeof value === 'object' &&
         value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
       ) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+        throw new BSONVersionError();
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
       } else if (type === 'object' && value._bsontype === 'Decimal128') {

package/src/regexp.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 import { BSONError } from './error';
 import type { EJSONOptions } from './extended_json';
 
@@ -25,14 +25,10 @@ export interface BSONRegExpExtended {
  * @public
  * @category BSONType
  */
-export class BSONRegExp {
+export class BSONRegExp extends BSONValue {
   get _bsontype(): 'BSONRegExp' {
     return 'BSONRegExp';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   pattern!: string;
   options!: string;
@@ -41,6 +37,7 @@ export class BSONRegExp {
    * @param options - The regular expression options
    */
   constructor(pattern: string, options?: string) {
+    super();
     this.pattern = pattern;
     this.options = alphabetize(options ?? '');