bson 4.7.0 → 5.0.0-alpha.0

package/src/db_ref.ts

@@ -1,7 +1,6 @@
 import type { Document } from './bson';
 import type { EJSONOptions } from './extended_json';
 import type { ObjectId } from './objectid';
-import { isObjectLike } from './parser/utils';
 
 /** @public */
 export interface DBRefLike {
@@ -13,10 +12,14 @@ export interface DBRefLike {
 /** @internal */
 export function isDBRefLike(value: unknown): value is DBRefLike {
   return (
-    isObjectLike(value) &&
+    value != null &&
+    typeof value === 'object' &&
+    '$id' in value &&
     value.$id != null &&
+    '$ref' in value &&
     typeof value.$ref === 'string' &&
-    (value.$db == null || typeof value.$db === 'string')
+    // If '$db' is defined it MUST be a string, otherwise it should be absent
+    (!('$db' in value) || ('$db' in value && typeof value.$db === 'string'))
   );
 }
 
@@ -26,7 +29,13 @@ export function isDBRefLike(value: unknown): value is DBRefLike {
  * @category BSONType
  */
 export class DBRef {
-  _bsontype!: 'DBRef';
+  get _bsontype(): 'DBRef' {
+    return 'DBRef';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
   collection!: string;
   oid!: ObjectId;
@@ -39,8 +48,6 @@ 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) {
-    if (!(this instanceof DBRef)) return new DBRef(collection, oid, db, fields);
-
     // check if namespace has been provided
     const parts = collection.split('.');
     if (parts.length === 2) {
@@ -120,5 +127,3 @@ export class DBRef {
     })`;
   }
 }
-
-Object.defineProperty(DBRef.prototype, '_bsontype', { value: 'DBRef' });

package/src/decimal128.ts

@@ -1,7 +1,7 @@
-import { Buffer } from 'buffer';
 import { BSONTypeError } from './error';
 import { Long } from './long';
 import { isUint8Array } from './parser/utils';
+import { ByteUtils } from './utils/byte_utils';
 
 const PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
 const PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
@@ -13,16 +13,22 @@ const EXPONENT_BIAS = 6176;
 const MAX_DIGITS = 34;
 
 // Nan value bits as 32 bit values (due to lack of longs)
-const NAN_BUFFER = [
-  0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-].reverse();
+const NAN_BUFFER = ByteUtils.fromNumberArray(
+  [
+    0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ].reverse()
+);
 // Infinity value bits 32 bit values (due to lack of longs)
-const INF_NEGATIVE_BUFFER = [
-  0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-].reverse();
-const INF_POSITIVE_BUFFER = [
-  0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-].reverse();
+const INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray(
+  [
+    0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ].reverse()
+);
+const INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray(
+  [
+    0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ].reverse()
+);
 
 const EXPONENT_REGEX = /^([-+])?(\d+)?$/;
 
@@ -121,17 +127,21 @@ export interface Decimal128Extended {
  * @category BSONType
  */
 export class Decimal128 {
-  _bsontype!: 'Decimal128';
+  get _bsontype(): 'Decimal128' {
+    return 'Decimal128';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
-  readonly bytes!: Buffer;
+  readonly bytes!: Uint8Array;
 
   /**
    * @param bytes - a buffer containing the raw Decimal128 bytes in little endian order,
    *                or a string representation as returned by .toString()
    */
-  constructor(bytes: Buffer | string) {
-    if (!(this instanceof Decimal128)) return new Decimal128(bytes);
-
+  constructor(bytes: Uint8Array | string) {
     if (typeof bytes === 'string') {
       this.bytes = Decimal128.fromString(bytes).bytes;
     } else if (isUint8Array(bytes)) {
@@ -239,9 +249,9 @@ export class Decimal128 {
     // Check if user passed Infinity or NaN
     if (!isDigit(representation[index]) && representation[index] !== '.') {
       if (representation[index] === 'i' || representation[index] === 'I') {
-        return new Decimal128(Buffer.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
+        return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
       } else if (representation[index] === 'N') {
-        return new Decimal128(Buffer.from(NAN_BUFFER));
+        return new Decimal128(NAN_BUFFER);
       }
     }
 
@@ -285,7 +295,7 @@ export class Decimal128 {
       const match = representation.substr(++index).match(EXPONENT_REGEX);
 
       // No digits read
-      if (!match || !match[2]) return new Decimal128(Buffer.from(NAN_BUFFER));
+      if (!match || !match[2]) return new Decimal128(NAN_BUFFER);
 
       // Get exponent
       exponent = parseInt(match[0], 10);
@@ -295,7 +305,7 @@ export class Decimal128 {
     }
 
     // Return not a number
-    if (representation[index]) return new Decimal128(Buffer.from(NAN_BUFFER));
+    if (representation[index]) return new Decimal128(NAN_BUFFER);
 
     // Done reading input
     // Find first non-zero digit in digits
@@ -423,9 +433,7 @@ export class Decimal128 {
                 exponent = exponent + 1;
                 digits[dIdx] = 1;
               } else {
-                return new Decimal128(
-                  Buffer.from(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER)
-                );
+                return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
               }
             }
           }
@@ -503,7 +511,7 @@ export class Decimal128 {
     }
 
     // Encode into a buffer
-    const buffer = Buffer.alloc(16);
+    const buffer = ByteUtils.allocate(16);
     index = 0;
 
     // Encode the low 64 bits of the decimal
@@ -769,5 +777,3 @@ export class Decimal128 {
     return `new Decimal128("${this.toString()}")`;
   }
 }
-
-Object.defineProperty(Decimal128.prototype, '_bsontype', { value: 'Decimal128' });

package/src/double.ts

@@ -11,7 +11,13 @@ export interface DoubleExtended {
  * @category BSONType
  */
 export class Double {
-  _bsontype!: 'Double';
+  get _bsontype(): 'Double' {
+    return 'Double';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
   value!: number;
   /**
@@ -20,8 +26,6 @@ export class Double {
    * @param value - the number we want to represent as a double.
    */
   constructor(value: number) {
-    if (!(this instanceof Double)) return new Double(value);
-
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }
@@ -87,5 +91,3 @@ export class Double {
     return `new Double(${eJSON.$numberDouble})`;
   }
 }
-
-Object.defineProperty(Double.prototype, '_bsontype', { value: 'Double' });

package/src/error.ts

@@ -2,7 +2,6 @@
 export class BSONError extends Error {
   constructor(message: string) {
     super(message);
-    Object.setPrototypeOf(this, BSONError.prototype);
   }
 
   get name(): string {
@@ -14,7 +13,6 @@ export class BSONError extends Error {
 export class BSONTypeError extends TypeError {
   constructor(message: string) {
     super(message);
-    Object.setPrototypeOf(this, BSONTypeError.prototype);
   }
 
   get name(): string {

package/src/extended_json.ts

@@ -1,6 +1,7 @@
 import { Binary } from './binary';
 import type { Document } from './bson';
 import { Code } from './code';
+import { BSON_INT32_MAX, BSON_INT32_MIN, BSON_INT64_MAX, BSON_INT64_MIN } from './constants';
 import { DBRef, isDBRefLike } from './db_ref';
 import { Decimal128 } from './decimal128';
 import { Double } from './double';
@@ -10,13 +11,18 @@ import { Long } from './long';
 import { MaxKey } from './max_key';
 import { MinKey } from './min_key';
 import { ObjectId } from './objectid';
-import { isDate, isObjectLike, isRegExp } from './parser/utils';
+import { isDate, isRegExp } from './parser/utils';
 import { BSONRegExp } from './regexp';
 import { BSONSymbol } from './symbol';
 import { Timestamp } from './timestamp';
 
 /** @public */
-export type EJSONOptions = EJSON.Options;
+export type EJSONOptions = {
+  /** Output using the Extended JSON v1 spec */
+  legacy?: boolean;
+  /** Enable Extended JSON's `relaxed` mode, which attempts to return native JS types where possible, rather than BSON types */
+  relaxed?: boolean;
+};
 
 /** @internal */
 type BSONType =
@@ -34,20 +40,15 @@ type BSONType =
   | BSONSymbol
   | Timestamp;
 
-export function isBSONType(value: unknown): value is BSONType {
+function isBSONType(value: unknown): value is BSONType {
   return (
-    isObjectLike(value) && Reflect.has(value, '_bsontype') && typeof value._bsontype === 'string'
+    value != null &&
+    typeof value === 'object' &&
+    '_bsontype' in value &&
+    typeof value._bsontype === 'string'
   );
 }
 
-// INT32 boundaries
-const BSON_INT32_MAX = 0x7fffffff;
-const BSON_INT32_MIN = -0x80000000;
-// INT64 boundaries
-// const BSON_INT64_MAX = 0x7fffffffffffffff; // TODO(NODE-4377): This number cannot be precisely represented in JS
-const BSON_INT64_MAX = 0x8000000000000000;
-const BSON_INT64_MIN = -0x8000000000000000;
-
 // all the types where we don't need to do any special processing and can just pass the EJSON
 //straight to type.fromExtendedJSON
 const keysToCodecs = {
@@ -67,17 +68,21 @@ const keysToCodecs = {
 } as const;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function deserializeValue(value: any, options: EJSON.Options = {}) {
+function deserializeValue(value: any, options: EJSONOptions = {}) {
   if (typeof value === 'number') {
     if (options.relaxed || options.legacy) {
       return value;
     }
 
-    // if it's an integer, should interpret as smallest BSON integer
-    // that can represent it exactly. (if out of range, interpret as double.)
-    if (Math.floor(value) === value) {
-      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) return new Int32(value);
-      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) return Long.fromNumber(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) {
+        return new Int32(value);
+      }
+      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {
+        // TODO(NODE-4377): EJSON js number handling diverges from BSON
+        return Long.fromNumber(value);
+      }
     }
 
     // If the number is a non-integer or out of integer range, should interpret as BSON Double.
@@ -142,7 +147,7 @@ function deserializeValue(value: any, options: EJSON.Options = {}) {
   return value;
 }
 
-type EJSONSerializeOptions = EJSON.Options & {
+type EJSONSerializeOptions = EJSONOptions & {
   seenObjects: { obj: unknown; propertyName: string }[];
 };
 
@@ -216,16 +221,17 @@ function serializeValue(value: any, options: EJSONSerializeOptions): any {
   }
 
   if (typeof value === 'number' && (!options.relaxed || !isFinite(value))) {
-    // it's an integer
-    if (Math.floor(value) === value) {
-      const int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX,
-        int64Range = value >= BSON_INT64_MIN && value <= BSON_INT64_MAX;
-
+    if (Number.isInteger(value) && !Object.is(value, -0)) {
       // interpret as being of the smallest BSON integer type that can represent the number exactly
-      if (int32Range) return { $numberInt: value.toString() };
-      if (int64Range) return { $numberLong: value.toString() };
+      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
+        return { $numberInt: value.toString() };
+      }
+      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {
+        // TODO(NODE-4377): EJSON js number handling diverges from BSON
+        return { $numberLong: value.toString() };
+      }
     }
-    return { $numberDouble: value.toString() };
+    return { $numberDouble: Object.is(value, -0) ? '-0.0' : value.toString() };
   }
 
   if (value instanceof RegExp || isRegExp(value)) {
@@ -267,10 +273,9 @@ const BSON_TYPE_MAPPINGS = {
     ),
   MaxKey: () => new MaxKey(),
   MinKey: () => new MinKey(),
-  ObjectID: (o: ObjectId) => new ObjectId(o),
-  ObjectId: (o: ObjectId) => new ObjectId(o), // support 4.0.0/4.0.1 before _bsontype was reverted back to ObjectID
+  ObjectId: (o: ObjectId) => new ObjectId(o),
   BSONRegExp: (o: BSONRegExp) => new BSONRegExp(o.pattern, o.options),
-  Symbol: (o: BSONSymbol) => new BSONSymbol(o.value),
+  BSONSymbol: (o: BSONSymbol) => new BSONSymbol(o.value),
   Timestamp: (o: Timestamp) => Timestamp.fromBits(o.low, o.high)
 } as const;
 
@@ -282,7 +287,7 @@ function serializeDocument(doc: any, options: EJSONSerializeOptions) {
   if (typeof bsontype === 'undefined') {
     // It's a regular object. Recursively serialize its property values.
     const _doc: Document = {};
-    for (const name in doc) {
+    for (const name of Object.keys(doc)) {
       options.seenObjects.push({ propertyName: name, obj: null });
       try {
         const value = serializeValue(doc[name], options);
@@ -301,6 +306,13 @@ function serializeDocument(doc: any, options: EJSONSerializeOptions) {
       }
     }
     return _doc;
+  } else if (
+    doc != null &&
+    typeof doc === 'object' &&
+    typeof doc._bsontype === 'string' &&
+    doc[Symbol.for('@@mdb.bson.version')] == null
+  ) {
+    throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
   } else if (isBSONType(doc)) {
     // the "document" is really just a BSON type object
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -336,127 +348,115 @@ function serializeDocument(doc: any, options: EJSONSerializeOptions) {
 }
 
 /**
- * EJSON parse / stringify API
- * @public
+ * 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" } }';
+ *
+ * // prints { int32: { [String: '10'] _bsontype: 'Int32', value: '10' } }
+ * console.log(EJSON.parse(text, { relaxed: false }));
+ *
+ * // prints { int32: 10 }
+ * console.log(EJSON.parse(text));
+ * ```
  */
-// the namespace here is used to emulate `export * as EJSON from '...'`
-// which as of now (sept 2020) api-extractor does not support
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace EJSON {
-  export interface Options {
-    /** Output using the Extended JSON v1 spec */
-    legacy?: boolean;
-    /** Enable Extended JSON's `relaxed` mode, which attempts to return native JS types where possible, rather than BSON types */
-    relaxed?: boolean;
-    /**
-     * Disable Extended JSON's `relaxed` mode, which attempts to return BSON types where possible, rather than native JS types
-     * @deprecated Please use the relaxed property instead
-     */
-    strict?: boolean;
-  }
-
-  /**
-   * 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" } }';
-   *
-   * // prints { int32: { [String: '10'] _bsontype: 'Int32', value: '10' } }
-   * console.log(EJSON.parse(text, { relaxed: false }));
-   *
-   * // prints { int32: 10 }
-   * console.log(EJSON.parse(text));
-   * ```
-   */
-  export function parse(text: string, options?: EJSON.Options): SerializableTypes {
-    const finalOptions = Object.assign({}, { relaxed: true, legacy: false }, options);
-
-    // relaxed implies not strict
-    if (typeof finalOptions.relaxed === 'boolean') finalOptions.strict = !finalOptions.relaxed;
-    if (typeof finalOptions.strict === 'boolean') finalOptions.relaxed = !finalOptions.strict;
-
-    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, finalOptions);
-    });
-  }
-
-  export type JSONPrimitive = string | number | boolean | null;
-  export type SerializableTypes = Document | Array<JSONPrimitive | Document> | JSONPrimitive;
-
-  /**
-   * 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.
-   *
-   * @param value - The value to convert to extended JSON
-   * @param replacer - 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
-   * @param space - A String or Number object that's used to insert white space into the output JSON string for readability purposes.
-   * @param options - Optional settings
-   *
-   * @example
-   * ```js
-   * const { EJSON } = require('bson');
-   * const Int32 = require('mongodb').Int32;
-   * const doc = { int32: new Int32(10) };
-   *
-   * // prints '{"int32":{"$numberInt":"10"}}'
-   * console.log(EJSON.stringify(doc, { relaxed: false }));
-   *
-   * // prints '{"int32":10}'
-   * console.log(EJSON.stringify(doc));
-   * ```
-   */
-  export function stringify(
-    value: SerializableTypes,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    replacer?: (number | string)[] | ((this: any, key: string, value: any) => any) | EJSON.Options,
-    space?: string | number,
-    options?: EJSON.Options
-  ): string {
-    if (space != null && typeof space === 'object') {
-      options = space;
-      space = 0;
-    }
-    if (replacer != null && typeof replacer === 'object' && !Array.isArray(replacer)) {
-      options = replacer;
-      replacer = undefined;
-      space = 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parse(text: string, options?: EJSONOptions): any {
+  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)}`
+      );
     }
-    const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, {
-      seenObjects: [{ propertyName: '(root)', obj: null }]
-    });
+    return deserializeValue(value, { relaxed: true, legacy: false, ...options });
+  });
+}
 
-    const doc = serializeValue(value, serializeOptions);
-    return JSON.stringify(doc, replacer as Parameters<JSON['stringify']>[1], space);
+/**
+ * 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.
+ *
+ * @param value - The value to convert to extended JSON
+ * @param replacer - 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
+ * @param space - A String or Number object that's used to insert white space into the output JSON string for readability purposes.
+ * @param options - Optional settings
+ *
+ * @example
+ * ```js
+ * const { EJSON } = require('bson');
+ * const Int32 = require('mongodb').Int32;
+ * const doc = { int32: new Int32(10) };
+ *
+ * // prints '{"int32":{"$numberInt":"10"}}'
+ * console.log(EJSON.stringify(doc, { relaxed: false }));
+ *
+ * // prints '{"int32":10}'
+ * console.log(EJSON.stringify(doc));
+ * ```
+ */
+function stringify(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  value: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  replacer?: (number | string)[] | ((this: any, key: string, value: any) => any) | EJSONOptions,
+  space?: string | number,
+  options?: EJSONOptions
+): string {
+  if (space != null && typeof space === 'object') {
+    options = space;
+    space = 0;
   }
-
-  /**
-   * Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.
-   *
-   * @param value - The object to serialize
-   * @param options - Optional settings passed to the `stringify` function
-   */
-  export function serialize(value: SerializableTypes, options?: EJSON.Options): Document {
-    options = options || {};
-    return JSON.parse(stringify(value, options));
+  if (replacer != null && typeof replacer === 'object' && !Array.isArray(replacer)) {
+    options = replacer;
+    replacer = undefined;
+    space = 0;
   }
+  const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, {
+    seenObjects: [{ propertyName: '(root)', obj: null }]
+  });
 
-  /**
-   * Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types
-   *
-   * @param ejson - The Extended JSON object to deserialize
-   * @param options - Optional settings passed to the parse method
-   */
-  export function deserialize(ejson: Document, options?: EJSON.Options): SerializableTypes {
-    options = options || {};
-    return parse(JSON.stringify(ejson), options);
-  }
+  const doc = serializeValue(value, serializeOptions);
+  return JSON.stringify(doc, replacer as Parameters<JSON['stringify']>[1], space);
 }
+
+/**
+ * Serializes an object to an Extended JSON string, and reparse it as a JavaScript object.
+ *
+ * @param value - The object to serialize
+ * @param options - Optional settings passed to the `stringify` function
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function EJSONserialize(value: any, options?: EJSONOptions): Document {
+  options = options || {};
+  return JSON.parse(stringify(value, options));
+}
+
+/**
+ * Deserializes an Extended JSON object into a plain JavaScript object with native/BSON types
+ *
+ * @param ejson - The Extended JSON object to deserialize
+ * @param options - Optional settings passed to the parse method
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function EJSONdeserialize(ejson: Document, options?: EJSONOptions): any {
+  options = options || {};
+  return parse(JSON.stringify(ejson), options);
+}
+
+/** @public */
+const EJSON: {
+  parse: typeof parse;
+  stringify: typeof stringify;
+  serialize: typeof EJSONserialize;
+  deserialize: typeof EJSONdeserialize;
+} = Object.create(null);
+EJSON.parse = parse;
+EJSON.stringify = stringify;
+EJSON.serialize = EJSONserialize;
+EJSON.deserialize = EJSONdeserialize;
+Object.freeze(EJSON);
+export { EJSON };

package/src/index.ts

@@ -0,0 +1,19 @@
+import * as BSON from './bson';
+
+// Export all named properties from BSON to support
+// import { ObjectId, serialize } from 'bson';
+// const { ObjectId, serialize } = require('bson');
+export * from './bson';
+
+// Export BSON as a namespace to support:
+// import { BSON } from 'bson';
+// const { BSON } = require('bson');
+export { BSON };
+
+// BSON does **NOT** have a default export
+
+// The following will crash in es module environments
+// import BSON from 'bson';
+
+// The following will work as expected, BSON as a namespace of all the APIs (BSON.ObjectId, BSON.serialize)
+// const BSON = require('bson');

package/src/int_32.ts

@@ -11,7 +11,13 @@ export interface Int32Extended {
  * @category BSONType
  */
 export class Int32 {
-  _bsontype!: 'Int32';
+  get _bsontype(): 'Int32' {
+    return 'Int32';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
   value!: number;
   /**
@@ -20,8 +26,6 @@ export class Int32 {
    * @param value - the number we want to represent as an int32.
    */
   constructor(value: number | string) {
-    if (!(this instanceof Int32)) return new Int32(value);
-
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }
@@ -66,5 +70,3 @@ export class Int32 {
     return `new Int32(${this.valueOf()})`;
   }
 }
-
-Object.defineProperty(Int32.prototype, '_bsontype', { value: 'Int32' });