bson 4.7.0 → 5.0.0-alpha.0

package/src/binary.ts

@@ -1,13 +1,12 @@
-import { Buffer } from 'buffer';
-import { ensureBuffer } from './ensure_buffer';
 import { bufferToUuidHexString, uuidHexStringToBuffer, uuidValidateString } from './uuid_utils';
-import { isUint8Array, randomBytes } from './parser/utils';
+import { isUint8Array } from './parser/utils';
 import type { EJSONOptions } from './extended_json';
 import { BSONError, BSONTypeError } from './error';
 import { BSON_BINARY_SUBTYPE_UUID_NEW } from './constants';
+import { ByteUtils } from './utils/byte_utils';
 
 /** @public */
-export type BinarySequence = Uint8Array | Buffer | number[];
+export type BinarySequence = Uint8Array | number[];
 
 /** @public */
 export interface BinaryExtendedLegacy {
@@ -29,7 +28,13 @@ export interface BinaryExtended {
  * @category BSONType
  */
 export class Binary {
-  _bsontype!: 'Binary';
+  get _bsontype(): 'Binary' {
+    return 'Binary';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
 
   /**
    * Binary default subtype
@@ -58,7 +63,7 @@ export class Binary {
   /** User BSON type */
   static readonly SUBTYPE_USER_DEFINED = 128;
 
-  buffer!: Buffer;
+  buffer!: Uint8Array;
   sub_type!: number;
   position!: number;
 
@@ -74,8 +79,6 @@ export class Binary {
    * @param subType - the option binary type.
    */
   constructor(buffer?: string | BinarySequence, subType?: number) {
-    if (!(this instanceof Binary)) return new Binary(buffer, subType);
-
     if (
       !(buffer == null) &&
       !(typeof buffer === 'string') &&
@@ -92,18 +95,18 @@ export class Binary {
 
     if (buffer == null) {
       // create an empty binary buffer
-      this.buffer = Buffer.alloc(Binary.BUFFER_SIZE);
+      this.buffer = ByteUtils.allocate(Binary.BUFFER_SIZE);
       this.position = 0;
     } else {
       if (typeof buffer === 'string') {
         // string
-        this.buffer = Buffer.from(buffer, 'binary');
+        this.buffer = ByteUtils.fromISO88591(buffer);
       } else if (Array.isArray(buffer)) {
         // number[]
-        this.buffer = Buffer.from(buffer);
+        this.buffer = ByteUtils.fromNumberArray(buffer);
       } else {
         // Buffer | TypedArray | ArrayBuffer
-        this.buffer = ensureBuffer(buffer);
+        this.buffer = ByteUtils.toLocalBufferType(buffer);
       }
 
       this.position = this.buffer.byteLength;
@@ -115,7 +118,7 @@ export class Binary {
    *
    * @param byteValue - a single byte we wish to write.
    */
-  put(byteValue: string | number | Uint8Array | Buffer | number[]): void {
+  put(byteValue: string | number | Uint8Array | number[]): void {
     // If it's a string and a has more than one character throw an error
     if (typeof byteValue === 'string' && byteValue.length !== 1) {
       throw new BSONTypeError('only accepts single character String');
@@ -136,13 +139,12 @@ export class Binary {
       throw new BSONTypeError('only accepts number in a valid unsigned byte range 0-255');
     }
 
-    if (this.buffer.length > this.position) {
+    if (this.buffer.byteLength > this.position) {
       this.buffer[this.position++] = decodedByte;
     } else {
-      const buffer = Buffer.alloc(Binary.BUFFER_SIZE + this.buffer.length);
-      // Combine the two buffers together
-      this.buffer.copy(buffer, 0, 0, this.buffer.length);
-      this.buffer = buffer;
+      const newSpace = ByteUtils.allocate(Binary.BUFFER_SIZE + this.buffer.length);
+      newSpace.set(this.buffer, 0);
+      this.buffer = newSpace;
       this.buffer[this.position++] = decodedByte;
     }
   }
@@ -157,20 +159,21 @@ export class Binary {
     offset = typeof offset === 'number' ? offset : this.position;
 
     // If the buffer is to small let's extend the buffer
-    if (this.buffer.length < offset + sequence.length) {
-      const buffer = Buffer.alloc(this.buffer.length + sequence.length);
-      this.buffer.copy(buffer, 0, 0, this.buffer.length);
+    if (this.buffer.byteLength < offset + sequence.length) {
+      const newSpace = ByteUtils.allocate(this.buffer.byteLength + sequence.length);
+      newSpace.set(this.buffer, 0);
 
       // Assign the new buffer
-      this.buffer = buffer;
+      this.buffer = newSpace;
     }
 
     if (ArrayBuffer.isView(sequence)) {
-      this.buffer.set(ensureBuffer(sequence), offset);
+      this.buffer.set(ByteUtils.toLocalBufferType(sequence), offset);
       this.position =
         offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;
     } else if (typeof sequence === 'string') {
-      this.buffer.write(sequence, offset, sequence.length, 'binary');
+      const bytes = ByteUtils.fromISO88591(sequence);
+      this.buffer.set(bytes, offset);
       this.position =
         offset + sequence.length > this.position ? offset + sequence.length : this.position;
     }
@@ -207,7 +210,8 @@ export class Binary {
     if (asRaw) {
       return this.buffer.slice(0, this.position);
     }
-    return this.buffer.toString('binary', 0, this.position);
+    // TODO(NODE-4361): remove binary string support, value(true) should be the default / only option here.
+    return ByteUtils.toISO88591(this.buffer.subarray(0, this.position));
   }
 
   /** the length of the binary sequence */
@@ -216,17 +220,20 @@ export class Binary {
   }
 
   toJSON(): string {
-    return this.buffer.toString('base64');
+    return ByteUtils.toBase64(this.buffer);
   }
 
-  toString(format?: string): string {
-    return this.buffer.toString(format);
+  toString(encoding?: 'hex' | 'base64' | 'utf8' | 'utf-8'): string {
+    if (encoding === 'hex') return ByteUtils.toHex(this.buffer);
+    if (encoding === 'base64') return ByteUtils.toBase64(this.buffer);
+    if (encoding === 'utf8' || encoding === 'utf-8') return ByteUtils.toUTF8(this.buffer);
+    return ByteUtils.toUTF8(this.buffer);
   }
 
   /** @internal */
   toExtendedJSON(options?: EJSONOptions): BinaryExtendedLegacy | BinaryExtended {
     options = options || {};
-    const base64String = this.buffer.toString('base64');
+    const base64String = ByteUtils.toBase64(this.buffer);
 
     const subType = Number(this.sub_type).toString(16);
     if (options.legacy) {
@@ -259,16 +266,16 @@ export class Binary {
     options?: EJSONOptions
   ): Binary {
     options = options || {};
-    let data: Buffer | undefined;
+    let data: Uint8Array | undefined;
     let type;
     if ('$binary' in doc) {
       if (options.legacy && typeof doc.$binary === 'string' && '$type' in doc) {
         type = doc.$type ? parseInt(doc.$type, 16) : 0;
-        data = Buffer.from(doc.$binary, 'base64');
+        data = ByteUtils.fromBase64(doc.$binary);
       } else {
         if (typeof doc.$binary !== 'string') {
           type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0;
-          data = Buffer.from(doc.$binary.base64, 'base64');
+          data = ByteUtils.fromBase64(doc.$binary.base64);
         }
       }
     } else if ('$uuid' in doc) {
@@ -287,13 +294,10 @@ export class Binary {
   }
 
   inspect(): string {
-    const asBuffer = this.value(true);
-    return `new Binary(Buffer.from("${asBuffer.toString('hex')}", "hex"), ${this.sub_type})`;
+    return `new Binary(Buffer.from("${ByteUtils.toHex(this.buffer)}", "hex"), ${this.sub_type})`;
   }
 }
 
-Object.defineProperty(Binary.prototype, '_bsontype', { value: 'Binary' });
-
 /** @public */
 export type UUIDExtended = {
   $uuid: string;
@@ -305,6 +309,11 @@ const UUID_BYTE_LENGTH = 16;
  * @public
  */
 export class UUID extends Binary {
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
+
   static cacheHexString: boolean;
 
   /** UUID hexString cache @internal */
@@ -315,16 +324,16 @@ export class UUID extends Binary {
    *
    * @param input - Can be a 32 or 36 character hex string (dashes excluded/included) or a 16 byte binary Buffer.
    */
-  constructor(input?: string | Buffer | UUID) {
-    let bytes;
+  constructor(input?: string | Uint8Array | UUID) {
+    let bytes: Uint8Array;
     let hexStr;
     if (input == null) {
       bytes = UUID.generate();
     } else if (input instanceof UUID) {
-      bytes = Buffer.from(input.buffer);
+      bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));
       hexStr = input.__id;
     } else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
-      bytes = ensureBuffer(input);
+      bytes = ByteUtils.toLocalBufferType(input);
     } else if (typeof input === 'string') {
       bytes = uuidHexStringToBuffer(input);
     } else {
@@ -340,11 +349,11 @@ export class UUID extends Binary {
    * The UUID bytes
    * @readonly
    */
-  get id(): Buffer {
+  get id(): Uint8Array {
     return this.buffer;
   }
 
-  set id(value: Buffer) {
+  set id(value: Uint8Array) {
     this.buffer = value;
 
     if (UUID.cacheHexString) {
@@ -373,8 +382,10 @@ export class UUID extends Binary {
   /**
    * Converts the id into a 36 character (dashes included) hex string, unless a encoding is specified.
    */
-  toString(encoding?: string): string {
-    return encoding ? this.id.toString(encoding) : this.toHexString();
+  toString(encoding?: 'hex' | 'base64'): string {
+    if (encoding === 'hex') return ByteUtils.toHex(this.id);
+    if (encoding === 'base64') return ByteUtils.toBase64(this.id);
+    return this.toHexString();
   }
 
   /**
@@ -390,17 +401,17 @@ export class UUID extends Binary {
    *
    * @param otherId - UUID instance to compare against.
    */
-  equals(otherId: string | Buffer | UUID): boolean {
+  equals(otherId: string | Uint8Array | UUID): boolean {
     if (!otherId) {
       return false;
     }
 
     if (otherId instanceof UUID) {
-      return otherId.id.equals(this.id);
+      return ByteUtils.equals(otherId.id, this.id);
     }
 
     try {
-      return new UUID(otherId).id.equals(this.id);
+      return ByteUtils.equals(new UUID(otherId).id, this.id);
     } catch {
       return false;
     }
@@ -416,22 +427,22 @@ export class UUID extends Binary {
   /**
    * Generates a populated buffer containing a v4 uuid
    */
-  static generate(): Buffer {
-    const bytes = randomBytes(UUID_BYTE_LENGTH);
+  static generate(): Uint8Array {
+    const bytes = ByteUtils.randomBytes(UUID_BYTE_LENGTH);
 
     // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
     // Kindly borrowed from https://github.com/uuidjs/uuid/blob/master/src/v4.js
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
 
-    return Buffer.from(bytes);
+    return bytes;
   }
 
   /**
    * Checks if a value is a valid bson UUID
    * @param input - UUID, string or Buffer to validate.
    */
-  static isValid(input: string | Buffer | UUID): boolean {
+  static isValid(input: string | Uint8Array | UUID): boolean {
     if (!input) {
       return false;
     }
@@ -446,7 +457,7 @@ export class UUID extends Binary {
 
     if (isUint8Array(input)) {
       // check for length & uuid version (https://tools.ietf.org/html/rfc4122#section-4.1.3)
-      if (input.length !== UUID_BYTE_LENGTH) {
+      if (input.byteLength !== UUID_BYTE_LENGTH) {
         return false;
       }
 

package/src/bson.ts

@@ -1,68 +1,27 @@
-import { Buffer } from 'buffer';
 import { Binary, UUID } from './binary';
 import { Code } from './code';
 import { DBRef } from './db_ref';
 import { Decimal128 } from './decimal128';
 import { Double } from './double';
-import { ensureBuffer } from './ensure_buffer';
-import { EJSON } from './extended_json';
 import { Int32 } from './int_32';
 import { Long } from './long';
-import { Map } from './map';
 import { MaxKey } from './max_key';
 import { MinKey } from './min_key';
 import { ObjectId } from './objectid';
-import { BSONError, BSONTypeError } from './error';
-import { calculateObjectSize as internalCalculateObjectSize } from './parser/calculate_size';
+import { internalCalculateObjectSize } from './parser/calculate_size';
 // Parts of the parser
-import { deserialize as internalDeserialize, DeserializeOptions } from './parser/deserializer';
-import { serializeInto as internalSerialize, SerializeOptions } from './parser/serializer';
+import { internalDeserialize, DeserializeOptions } from './parser/deserializer';
+import { serializeInto, SerializeOptions } from './parser/serializer';
 import { BSONRegExp } from './regexp';
 import { BSONSymbol } from './symbol';
 import { Timestamp } from './timestamp';
+import { ByteUtils } from './utils/byte_utils';
 export type { UUIDExtended, BinaryExtended, BinaryExtendedLegacy, BinarySequence } from './binary';
 export type { CodeExtended } from './code';
-export {
-  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_BINARY_SUBTYPE_ENCRYPTED,
-  BSON_BINARY_SUBTYPE_COLUMN,
-  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
-} from './constants';
 export type { DBRefLike } from './db_ref';
 export type { Decimal128Extended } from './decimal128';
 export type { DoubleExtended } from './double';
 export type { EJSONOptions } from './extended_json';
-export { EJSON } from './extended_json';
 export type { Int32Extended } from './int_32';
 export type { LongExtended } from './long';
 export type { MaxKeyExtended } from './max_key';
@@ -71,11 +30,11 @@ export type { ObjectIdExtended, ObjectIdLike } from './objectid';
 export type { BSONRegExpExtended, BSONRegExpExtendedLegacy } from './regexp';
 export type { BSONSymbolExtended } from './symbol';
 export type { LongWithoutOverrides, TimestampExtended, TimestampOverrides } from './timestamp';
-export { LongWithoutOverridesClass } from './timestamp';
+export type { LongWithoutOverridesClass } from './timestamp';
 export type { SerializeOptions, DeserializeOptions };
+
 export {
   Code,
-  Map,
   BSONSymbol,
   DBRef,
   Binary,
@@ -88,13 +47,11 @@ export {
   MinKey,
   MaxKey,
   BSONRegExp,
-  Decimal128,
-  // In 4.0.0 and 4.0.1, this property name was changed to ObjectId to match the class name.
-  // This caused interoperability problems with previous versions of the library, so in
-  // later builds we changed it back to ObjectID (capital D) to match legacy implementations.
-  ObjectId as ObjectID
+  Decimal128
 };
 export { BSONError, BSONTypeError } from './error';
+export { BSONType } from './constants';
+export { EJSON } from './extended_json';
 
 /** @public */
 export interface Document {
@@ -107,7 +64,7 @@ export interface Document {
 const MAXSIZE = 1024 * 1024 * 17;
 
 // Current Internal Temporary Serialization Buffer
-let buffer = Buffer.alloc(MAXSIZE);
+let buffer = ByteUtils.allocate(MAXSIZE);
 
 /**
  * Sets the size of the internal serialization buffer.
@@ -118,7 +75,7 @@ let buffer = Buffer.alloc(MAXSIZE);
 export function setInternalBufferSize(size: number): void {
   // Resize the internal serialization buffer if needed
   if (buffer.length < size) {
-    buffer = Buffer.alloc(size);
+    buffer = ByteUtils.allocate(size);
   }
 }
 
@@ -129,7 +86,7 @@ export function setInternalBufferSize(size: number): void {
  * @returns Buffer object containing the serialized object.
  * @public
  */
-export function serialize(object: Document, options: SerializeOptions = {}): Buffer {
+export function serialize(object: Document, options: SerializeOptions = {}): Uint8Array {
   // Unpack the options
   const checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;
   const serializeFunctions =
@@ -141,11 +98,11 @@ export function serialize(object: Document, options: SerializeOptions = {}): Buf
 
   // Resize the internal serialization buffer if needed
   if (buffer.length < minInternalBufferSize) {
-    buffer = Buffer.alloc(minInternalBufferSize);
+    buffer = ByteUtils.allocate(minInternalBufferSize);
   }
 
   // Attempt to serialize
-  const serializationIndex = internalSerialize(
+  const serializationIndex = serializeInto(
     buffer,
     object,
     checkKeys,
@@ -153,14 +110,14 @@ export function serialize(object: Document, options: SerializeOptions = {}): Buf
     0,
     serializeFunctions,
     ignoreUndefined,
-    []
+    null
   );
 
   // Create the final buffer
-  const finishedBuffer = Buffer.alloc(serializationIndex);
+  const finishedBuffer = ByteUtils.allocate(serializationIndex);
 
   // Copy into the finished buffer
-  buffer.copy(finishedBuffer, 0, 0, finishedBuffer.length);
+  finishedBuffer.set(buffer.subarray(0, serializationIndex), 0);
 
   // Return the buffer
   return finishedBuffer;
@@ -177,7 +134,7 @@ export function serialize(object: Document, options: SerializeOptions = {}): Buf
  */
 export function serializeWithBufferAndIndex(
   object: Document,
-  finalBuffer: Buffer,
+  finalBuffer: Uint8Array,
   options: SerializeOptions = {}
 ): number {
   // Unpack the options
@@ -189,16 +146,18 @@ export function serializeWithBufferAndIndex(
   const startIndex = typeof options.index === 'number' ? options.index : 0;
 
   // Attempt to serialize
-  const serializationIndex = internalSerialize(
+  const serializationIndex = serializeInto(
     buffer,
     object,
     checkKeys,
     0,
     0,
     serializeFunctions,
-    ignoreUndefined
+    ignoreUndefined,
+    null
   );
-  buffer.copy(finalBuffer, startIndex, 0, serializationIndex);
+
+  finalBuffer.set(buffer.subarray(0, serializationIndex), startIndex);
 
   // Return the index
   return startIndex + serializationIndex - 1;
@@ -211,11 +170,8 @@ export function serializeWithBufferAndIndex(
  * @returns returns the deserialized Javascript Object.
  * @public
  */
-export function deserialize(
-  buffer: Buffer | ArrayBufferView | ArrayBuffer,
-  options: DeserializeOptions = {}
-): Document {
-  return internalDeserialize(buffer instanceof Buffer ? buffer : ensureBuffer(buffer), options);
+export function deserialize(buffer: Uint8Array, options: DeserializeOptions = {}): Document {
+  return internalDeserialize(ByteUtils.toLocalBufferType(buffer), options);
 }
 
 /** @public */
@@ -258,7 +214,7 @@ export function calculateObjectSize(
  * @public
  */
 export function deserializeStream(
-  data: Buffer | ArrayBufferView | ArrayBuffer,
+  data: Uint8Array | ArrayBuffer,
   startIndex: number,
   numberOfDocuments: number,
   documents: Document[],
@@ -269,7 +225,7 @@ export function deserializeStream(
     { allowObjectSmallerThanBufferSize: true, index: 0 },
     options
   );
-  const bufferData = ensureBuffer(data);
+  const bufferData = ByteUtils.toLocalBufferType(data);
 
   let index = startIndex;
   // Loop over all documents
@@ -291,40 +247,3 @@ export function deserializeStream(
   // Return object containing end index of parsing and list of documents
   return index;
 }
-
-/**
- * BSON default export
- * @deprecated Please use named exports
- * @privateRemarks
- * We want to someday deprecate the default export,
- * so none of the new TS types are being exported on the default
- * @public
- */
-const BSON = {
-  Binary,
-  Code,
-  DBRef,
-  Decimal128,
-  Double,
-  Int32,
-  Long,
-  UUID,
-  Map,
-  MaxKey,
-  MinKey,
-  ObjectId,
-  ObjectID: ObjectId,
-  BSONRegExp,
-  BSONSymbol,
-  Timestamp,
-  EJSON,
-  setInternalBufferSize,
-  serialize,
-  serializeWithBufferAndIndex,
-  deserialize,
-  calculateObjectSize,
-  deserializeStream,
-  BSONError,
-  BSONTypeError
-};
-export default BSON;

package/src/code.ts

@@ -2,7 +2,7 @@ import type { Document } from './bson';
 
 /** @public */
 export interface CodeExtended {
-  $code: string | Function;
+  $code: string;
   $scope?: Document;
 }
 
@@ -12,23 +12,35 @@ export interface CodeExtended {
  * @category BSONType
  */
 export class Code {
-  _bsontype!: 'Code';
+  get _bsontype(): 'Code' {
+    return 'Code';
+  }
+  /** @internal */
+  get [Symbol.for('@@mdb.bson.version')](): 5 {
+    return 5;
+  }
+
+  code: string;
+
+  // a code instance having a null scope is what determines whether
+  // it is BSONType 0x0D (just code) / 0x0F (code with scope)
+  scope: Document | null;
 
-  code!: string | Function;
-  scope?: Document;
   /**
    * @param code - a string or function.
    * @param scope - an optional scope for the function.
    */
-  constructor(code: string | Function, scope?: Document) {
-    if (!(this instanceof Code)) return new Code(code, scope);
-
-    this.code = code;
-    this.scope = scope;
+  constructor(code: string | Function, scope?: Document | null) {
+    this.code = code.toString();
+    this.scope = scope ?? null;
   }
 
-  toJSON(): { code: string | Function; scope?: Document } {
-    return { code: this.code, scope: this.scope };
+  toJSON(): { code: string; scope?: Document } {
+    if (this.scope != null) {
+      return { code: this.code, scope: this.scope };
+    }
+
+    return { code: this.code };
   }
 
   /** @internal */
@@ -53,9 +65,7 @@ export class Code {
   inspect(): string {
     const codeJson = this.toJSON();
     return `new Code("${String(codeJson.code)}"${
-      codeJson.scope ? `, ${JSON.stringify(codeJson.scope)}` : ''
+      codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''
     })`;
   }
 }
-
-Object.defineProperty(Code.prototype, '_bsontype', { value: 'Code' });

package/src/constants.ts

@@ -108,3 +108,31 @@ export const BSON_BINARY_SUBTYPE_COLUMN = 7;
 
 /** Binary User Defined Type @internal */
 export const BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
+
+/** @public */
+export const BSONType = Object.freeze({
+  double: 1,
+  string: 2,
+  object: 3,
+  array: 4,
+  binData: 5,
+  undefined: 6,
+  objectId: 7,
+  bool: 8,
+  date: 9,
+  null: 10,
+  regex: 11,
+  dbPointer: 12,
+  javascript: 13,
+  symbol: 14,
+  javascriptWithScope: 15,
+  int: 16,
+  timestamp: 17,
+  long: 18,
+  decimal: 19,
+  minKey: -1,
+  maxKey: 127
+} as const);
+
+/** @public */
+export type BSONType = typeof BSONType[keyof typeof BSONType];