bson 6.8.0 → 6.10.0

package/src/parser/serializer.ts

@@ -1,4 +1,4 @@
-import { Binary } from '../binary';
+import { Binary, validateBinaryVector } from '../binary';
 import type { BSONSymbol, DBRef, Document, MaxKey } from '../bson';
 import type { Code } from '../code';
 import * as constants from '../constants';
@@ -495,6 +495,10 @@ function serializeBinary(buffer: Uint8Array, key: string, value: Binary, index:
     index += NumberUtils.setInt32LE(buffer, index, size);
   }
 
+  if (value.sub_type === Binary.SUBTYPE_VECTOR) {
+    validateBinaryVector(value);
+  }
+
   if (size <= 16) {
     for (let i = 0; i < size; i++) buffer[index + i] = data[i];
   } else {
@@ -633,77 +637,81 @@ export function serializeInto(
         value = value.toBSON();
       }
 
-      if (typeof value === 'string') {
+      // Check the type of the value
+      const type = typeof value;
+
+      if (value === undefined) {
+        index = serializeNull(buffer, key, value, index);
+      } else if (value === null) {
+        index = serializeNull(buffer, key, value, index);
+      } else if (type === 'string') {
         index = serializeString(buffer, key, value, index);
-      } else if (typeof value === 'number') {
+      } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
-      } else if (typeof value === 'bigint') {
+      } else if (type === 'bigint') {
         index = serializeBigInt(buffer, key, value, index);
-      } else if (typeof value === 'boolean') {
+      } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
-      } else if (value instanceof Date || isDate(value)) {
-        index = serializeDate(buffer, key, value, index);
-      } else if (value === undefined) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (value === null) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (isUint8Array(value)) {
-        index = serializeBuffer(buffer, key, value, index);
-      } else if (value instanceof RegExp || isRegExp(value)) {
-        index = serializeRegExp(buffer, key, value, index);
-      } else if (typeof value === 'object' && value._bsontype == null) {
-        index = serializeObject(
-          buffer,
-          key,
-          value,
-          index,
-          checkKeys,
-          depth,
-          serializeFunctions,
-          ignoreUndefined,
-          path
-        );
-      } else if (
-        typeof value === 'object' &&
-        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
-      ) {
-        throw new BSONVersionError();
-      } else if (value._bsontype === 'ObjectId') {
-        index = serializeObjectId(buffer, key, value, index);
-      } else if (value._bsontype === 'Decimal128') {
-        index = serializeDecimal128(buffer, key, value, index);
-      } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-        index = serializeLong(buffer, key, value, index);
-      } else if (value._bsontype === 'Double') {
-        index = serializeDouble(buffer, key, value, index);
-      } else if (typeof value === 'function' && serializeFunctions) {
+      } else if (type === 'object' && value._bsontype == null) {
+        if (value instanceof Date || isDate(value)) {
+          index = serializeDate(buffer, key, value, index);
+        } else if (value instanceof Uint8Array || isUint8Array(value)) {
+          index = serializeBuffer(buffer, key, value, index);
+        } else if (value instanceof RegExp || isRegExp(value)) {
+          index = serializeRegExp(buffer, key, value, index);
+        } else {
+          index = serializeObject(
+            buffer,
+            key,
+            value,
+            index,
+            checkKeys,
+            depth,
+            serializeFunctions,
+            ignoreUndefined,
+            path
+          );
+        }
+      } else if (type === 'object') {
+        if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
+          throw new BSONVersionError();
+        } else if (value._bsontype === 'ObjectId') {
+          index = serializeObjectId(buffer, key, value, index);
+        } else if (value._bsontype === 'Decimal128') {
+          index = serializeDecimal128(buffer, key, value, index);
+        } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+          index = serializeLong(buffer, key, value, index);
+        } else if (value._bsontype === 'Double') {
+          index = serializeDouble(buffer, key, value, index);
+        } else if (value._bsontype === 'Code') {
+          index = serializeCode(
+            buffer,
+            key,
+            value,
+            index,
+            checkKeys,
+            depth,
+            serializeFunctions,
+            ignoreUndefined,
+            path
+          );
+        } else if (value._bsontype === 'Binary') {
+          index = serializeBinary(buffer, key, value, index);
+        } else if (value._bsontype === 'BSONSymbol') {
+          index = serializeSymbol(buffer, key, value, index);
+        } else if (value._bsontype === 'DBRef') {
+          index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+        } else if (value._bsontype === 'BSONRegExp') {
+          index = serializeBSONRegExp(buffer, key, value, index);
+        } else if (value._bsontype === 'Int32') {
+          index = serializeInt32(buffer, key, value, index);
+        } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+          index = serializeMinMax(buffer, key, value, index);
+        } else if (typeof value._bsontype !== 'undefined') {
+          throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+        }
+      } else if (type === 'function' && serializeFunctions) {
         index = serializeFunction(buffer, key, value, index);
-      } else if (value._bsontype === 'Code') {
-        index = serializeCode(
-          buffer,
-          key,
-          value,
-          index,
-          checkKeys,
-          depth,
-          serializeFunctions,
-          ignoreUndefined,
-          path
-        );
-      } else if (value._bsontype === 'Binary') {
-        index = serializeBinary(buffer, key, value, index);
-      } else if (value._bsontype === 'BSONSymbol') {
-        index = serializeSymbol(buffer, key, value, index);
-      } else if (value._bsontype === 'DBRef') {
-        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
-      } else if (value._bsontype === 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index);
-      } else if (value._bsontype === 'Int32') {
-        index = serializeInt32(buffer, key, value, index);
-      } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-        index = serializeMinMax(buffer, key, value, index);
-      } else if (typeof value._bsontype !== 'undefined') {
-        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   } else if (object instanceof Map || isMap(object)) {
@@ -745,7 +753,11 @@ export function serializeInto(
         }
       }
 
-      if (type === 'string') {
+      if (value === undefined) {
+        if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);
+      } else if (value === null) {
+        index = serializeNull(buffer, key, value, index);
+      } else if (type === 'string') {
         index = serializeString(buffer, key, value, index);
       } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
@@ -753,67 +765,66 @@ export function serializeInto(
         index = serializeBigInt(buffer, key, value, index);
       } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
-      } else if (value instanceof Date || isDate(value)) {
-        index = serializeDate(buffer, key, value, index);
-      } else if (value === null || (value === undefined && ignoreUndefined === false)) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (isUint8Array(value)) {
-        index = serializeBuffer(buffer, key, value, index);
-      } else if (value instanceof RegExp || isRegExp(value)) {
-        index = serializeRegExp(buffer, key, value, index);
       } else if (type === 'object' && value._bsontype == null) {
-        index = serializeObject(
-          buffer,
-          key,
-          value,
-          index,
-          checkKeys,
-          depth,
-          serializeFunctions,
-          ignoreUndefined,
-          path
-        );
-      } else if (
-        typeof value === 'object' &&
-        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
-      ) {
-        throw new BSONVersionError();
-      } else if (value._bsontype === 'ObjectId') {
-        index = serializeObjectId(buffer, key, value, index);
-      } else if (type === 'object' && value._bsontype === 'Decimal128') {
-        index = serializeDecimal128(buffer, key, value, index);
-      } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-        index = serializeLong(buffer, key, value, index);
-      } else if (value._bsontype === 'Double') {
-        index = serializeDouble(buffer, key, value, index);
-      } else if (value._bsontype === 'Code') {
-        index = serializeCode(
-          buffer,
-          key,
-          value,
-          index,
-          checkKeys,
-          depth,
-          serializeFunctions,
-          ignoreUndefined,
-          path
-        );
-      } else if (typeof value === 'function' && serializeFunctions) {
+        if (value instanceof Date || isDate(value)) {
+          index = serializeDate(buffer, key, value, index);
+        } else if (value instanceof Uint8Array || isUint8Array(value)) {
+          index = serializeBuffer(buffer, key, value, index);
+        } else if (value instanceof RegExp || isRegExp(value)) {
+          index = serializeRegExp(buffer, key, value, index);
+        } else {
+          index = serializeObject(
+            buffer,
+            key,
+            value,
+            index,
+            checkKeys,
+            depth,
+            serializeFunctions,
+            ignoreUndefined,
+            path
+          );
+        }
+      } else if (type === 'object') {
+        if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
+          throw new BSONVersionError();
+        } else if (value._bsontype === 'ObjectId') {
+          index = serializeObjectId(buffer, key, value, index);
+        } else if (value._bsontype === 'Decimal128') {
+          index = serializeDecimal128(buffer, key, value, index);
+        } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+          index = serializeLong(buffer, key, value, index);
+        } else if (value._bsontype === 'Double') {
+          index = serializeDouble(buffer, key, value, index);
+        } else if (value._bsontype === 'Code') {
+          index = serializeCode(
+            buffer,
+            key,
+            value,
+            index,
+            checkKeys,
+            depth,
+            serializeFunctions,
+            ignoreUndefined,
+            path
+          );
+        } else if (value._bsontype === 'Binary') {
+          index = serializeBinary(buffer, key, value, index);
+        } else if (value._bsontype === 'BSONSymbol') {
+          index = serializeSymbol(buffer, key, value, index);
+        } else if (value._bsontype === 'DBRef') {
+          index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+        } else if (value._bsontype === 'BSONRegExp') {
+          index = serializeBSONRegExp(buffer, key, value, index);
+        } else if (value._bsontype === 'Int32') {
+          index = serializeInt32(buffer, key, value, index);
+        } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+          index = serializeMinMax(buffer, key, value, index);
+        } else if (typeof value._bsontype !== 'undefined') {
+          throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+        }
+      } else if (type === 'function' && serializeFunctions) {
         index = serializeFunction(buffer, key, value, index);
-      } else if (value._bsontype === 'Binary') {
-        index = serializeBinary(buffer, key, value, index);
-      } else if (value._bsontype === 'BSONSymbol') {
-        index = serializeSymbol(buffer, key, value, index);
-      } else if (value._bsontype === 'DBRef') {
-        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
-      } else if (value._bsontype === 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index);
-      } else if (value._bsontype === 'Int32') {
-        index = serializeInt32(buffer, key, value, index);
-      } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-        index = serializeMinMax(buffer, key, value, index);
-      } else if (typeof value._bsontype !== 'undefined') {
-        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   } else {
@@ -853,7 +864,11 @@ export function serializeInto(
         }
       }
 
-      if (type === 'string') {
+      if (value === undefined) {
+        if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);
+      } else if (value === null) {
+        index = serializeNull(buffer, key, value, index);
+      } else if (type === 'string') {
         index = serializeString(buffer, key, value, index);
       } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
@@ -861,69 +876,66 @@ export function serializeInto(
         index = serializeBigInt(buffer, key, value, index);
       } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
-      } else if (value instanceof Date || isDate(value)) {
-        index = serializeDate(buffer, key, value, index);
-      } else if (value === undefined) {
-        if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);
-      } else if (value === null) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (isUint8Array(value)) {
-        index = serializeBuffer(buffer, key, value, index);
-      } else if (value instanceof RegExp || isRegExp(value)) {
-        index = serializeRegExp(buffer, key, value, index);
       } else if (type === 'object' && value._bsontype == null) {
-        index = serializeObject(
-          buffer,
-          key,
-          value,
-          index,
-          checkKeys,
-          depth,
-          serializeFunctions,
-          ignoreUndefined,
-          path
-        );
-      } else if (
-        typeof value === 'object' &&
-        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
-      ) {
-        throw new BSONVersionError();
-      } else if (value._bsontype === 'ObjectId') {
-        index = serializeObjectId(buffer, key, value, index);
-      } else if (type === 'object' && value._bsontype === 'Decimal128') {
-        index = serializeDecimal128(buffer, key, value, index);
-      } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-        index = serializeLong(buffer, key, value, index);
-      } else if (value._bsontype === 'Double') {
-        index = serializeDouble(buffer, key, value, index);
-      } else if (value._bsontype === 'Code') {
-        index = serializeCode(
-          buffer,
-          key,
-          value,
-          index,
-          checkKeys,
-          depth,
-          serializeFunctions,
-          ignoreUndefined,
-          path
-        );
-      } else if (typeof value === 'function' && serializeFunctions) {
+        if (value instanceof Date || isDate(value)) {
+          index = serializeDate(buffer, key, value, index);
+        } else if (value instanceof Uint8Array || isUint8Array(value)) {
+          index = serializeBuffer(buffer, key, value, index);
+        } else if (value instanceof RegExp || isRegExp(value)) {
+          index = serializeRegExp(buffer, key, value, index);
+        } else {
+          index = serializeObject(
+            buffer,
+            key,
+            value,
+            index,
+            checkKeys,
+            depth,
+            serializeFunctions,
+            ignoreUndefined,
+            path
+          );
+        }
+      } else if (type === 'object') {
+        if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
+          throw new BSONVersionError();
+        } else if (value._bsontype === 'ObjectId') {
+          index = serializeObjectId(buffer, key, value, index);
+        } else if (value._bsontype === 'Decimal128') {
+          index = serializeDecimal128(buffer, key, value, index);
+        } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+          index = serializeLong(buffer, key, value, index);
+        } else if (value._bsontype === 'Double') {
+          index = serializeDouble(buffer, key, value, index);
+        } else if (value._bsontype === 'Code') {
+          index = serializeCode(
+            buffer,
+            key,
+            value,
+            index,
+            checkKeys,
+            depth,
+            serializeFunctions,
+            ignoreUndefined,
+            path
+          );
+        } else if (value._bsontype === 'Binary') {
+          index = serializeBinary(buffer, key, value, index);
+        } else if (value._bsontype === 'BSONSymbol') {
+          index = serializeSymbol(buffer, key, value, index);
+        } else if (value._bsontype === 'DBRef') {
+          index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+        } else if (value._bsontype === 'BSONRegExp') {
+          index = serializeBSONRegExp(buffer, key, value, index);
+        } else if (value._bsontype === 'Int32') {
+          index = serializeInt32(buffer, key, value, index);
+        } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+          index = serializeMinMax(buffer, key, value, index);
+        } else if (typeof value._bsontype !== 'undefined') {
+          throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+        }
+      } else if (type === 'function' && serializeFunctions) {
         index = serializeFunction(buffer, key, value, index);
-      } else if (value._bsontype === 'Binary') {
-        index = serializeBinary(buffer, key, value, index);
-      } else if (value._bsontype === 'BSONSymbol') {
-        index = serializeSymbol(buffer, key, value, index);
-      } else if (value._bsontype === 'DBRef') {
-        index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
-      } else if (value._bsontype === 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index);
-      } else if (value._bsontype === 'Int32') {
-        index = serializeInt32(buffer, key, value, index);
-      } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-        index = serializeMinMax(buffer, key, value, index);
-      } else if (typeof value._bsontype !== 'undefined') {
-        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   }

package/src/parser/utils.ts

@@ -1,31 +1,65 @@
+const map = new WeakMap<object, string>();
+
+const TYPES = {
+  ArrayBuffer: '[object ArrayBuffer]',
+  SharedArrayBuffer: '[object SharedArrayBuffer]',
+  Uint8Array: '[object Uint8Array]',
+  BigInt64Array: '[object BigInt64Array]',
+  BigUint64Array: '[object BigUint64Array]',
+  RegExp: '[object RegExp]',
+  Map: '[object Map]',
+  Date: '[object Date]'
+};
+
+/**
+ * Retrieves the prototype.toString() of a value.
+ * If the value is an object, it will cache the result in a WeakMap for future use.
+ */
+function getPrototypeString(value: unknown): string {
+  let str = map.get(value as object);
+
+  if (!str) {
+    str = Object.prototype.toString.call(value);
+    if (value !== null && typeof value === 'object') {
+      map.set(value, str);
+    }
+  }
+  return str;
+}
+
 export function isAnyArrayBuffer(value: unknown): value is ArrayBuffer {
-  return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(
-    Object.prototype.toString.call(value)
-  );
+  const type = getPrototypeString(value);
+  return type === TYPES.ArrayBuffer || type === TYPES.SharedArrayBuffer;
 }
 
 export function isUint8Array(value: unknown): value is Uint8Array {
-  return Object.prototype.toString.call(value) === '[object Uint8Array]';
+  const type = getPrototypeString(value);
+  return type === TYPES.Uint8Array;
 }
 
 export function isBigInt64Array(value: unknown): value is BigInt64Array {
-  return Object.prototype.toString.call(value) === '[object BigInt64Array]';
+  const type = getPrototypeString(value);
+  return type === TYPES.BigInt64Array;
 }
 
 export function isBigUInt64Array(value: unknown): value is BigUint64Array {
-  return Object.prototype.toString.call(value) === '[object BigUint64Array]';
+  const type = getPrototypeString(value);
+  return type === TYPES.BigUint64Array;
 }
 
 export function isRegExp(d: unknown): d is RegExp {
-  return Object.prototype.toString.call(d) === '[object RegExp]';
+  const type = getPrototypeString(d);
+  return type === TYPES.RegExp;
 }
 
 export function isMap(d: unknown): d is Map<unknown, unknown> {
-  return Object.prototype.toString.call(d) === '[object Map]';
+  const type = getPrototypeString(d);
+  return type === TYPES.Map;
 }
 
 export function isDate(d: unknown): d is Date {
-  return Object.prototype.toString.call(d) === '[object Date]';
+  const type = getPrototypeString(d);
+  return type === TYPES.Date;
 }
 
 export type InspectFn = (x: unknown, options?: unknown) => string;

package/src/timestamp.ts

@@ -28,6 +28,8 @@ export interface TimestampExtended {
 /**
  * @public
  * @category BSONType
+ *
+ * A special type for _internal_ MongoDB use and is **not** associated with the regular Date type.
  */
 export class Timestamp extends LongWithoutOverridesClass {
   get _bsontype(): 'Timestamp' {
@@ -36,6 +38,20 @@ export class Timestamp extends LongWithoutOverridesClass {
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 
+  /**
+   * An incrementing ordinal for operations within a given second.
+   */
+  get i(): number {
+    return this.low >>> 0;
+  }
+
+  /**
+   * A `time_t` value measuring seconds since the Unix epoch
+   */
+  get t(): number {
+    return this.high >>> 0;
+  }
+
   /**
    * @param int - A 64-bit bigint representing the Timestamp.
    */
@@ -127,7 +143,7 @@ export class Timestamp extends LongWithoutOverridesClass {
 
   /** @internal */
   toExtendedJSON(): TimestampExtended {
-    return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };
+    return { $timestamp: { t: this.t, i: this.i } };
   }
 
   /** @internal */
@@ -144,8 +160,8 @@ export class Timestamp extends LongWithoutOverridesClass {
 
   inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {
     inspect ??= defaultInspect;
-    const t = inspect(this.high >>> 0, options);
-    const i = inspect(this.low >>> 0, options);
+    const t = inspect(this.t, options);
+    const i = inspect(this.i, options);
     return `new Timestamp({ t: ${t}, i: ${i} })`;
   }
 }

package/src/utils/byte_utils.ts

@@ -39,6 +39,8 @@ export type ByteUtils = {
   encodeUTF8Into: (destination: Uint8Array, source: string, byteOffset: number) => number;
   /** Generate a Uint8Array filled with random bytes with byteLength */
   randomBytes: (byteLength: number) => Uint8Array;
+  /** Interprets `buffer` as an array of 32-bit values and swaps the byte order in-place. */
+  swap32: (buffer: Uint8Array) => Uint8Array;
 };
 
 declare const Buffer: { new (): unknown; prototype?: { _isBuffer?: boolean } } | undefined;

package/src/utils/node_byte_utils.ts

@@ -9,6 +9,7 @@ type NodeJsBuffer = ArrayBufferView &
     copy(target: Uint8Array, targetStart: number, sourceStart: number, sourceEnd: number): number;
     toString: (this: Uint8Array, encoding: NodeJsEncoding, start?: number, end?: number) => string;
     equals: (this: Uint8Array, other: Uint8Array) => boolean;
+    swap32: (this: NodeJsBuffer) => NodeJsBuffer;
   };
 type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
   alloc: (size: number) => NodeJsBuffer;
@@ -83,7 +84,7 @@ export const nodeJsByteUtils = {
       return Buffer.from(potentialBuffer);
     }
 
-    throw new BSONError(`Cannot create Buffer from ${String(potentialBuffer)}`);
+    throw new BSONError(`Cannot create Buffer from the passed potentialBuffer.`);
   },
 
   allocate(size: number): NodeJsBuffer {
@@ -159,5 +160,9 @@ export const nodeJsByteUtils = {
     return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');
   },
 
-  randomBytes: nodejsRandomBytes
+  randomBytes: nodejsRandomBytes,
+
+  swap32(buffer: Uint8Array): NodeJsBuffer {
+    return nodeJsByteUtils.toLocalBufferType(buffer).swap32();
+  }
 };

package/src/utils/number_utils.ts

@@ -13,6 +13,8 @@ const isBigEndian = FLOAT_BYTES[7] === 0;
  * A collection of functions that get or set various numeric types and bit widths from a Uint8Array.
  */
 export type NumberUtils = {
+  /** Is true if the current system is big endian. */
+  isBigEndian: boolean;
   /**
    * Parses a signed int32 at offset. Throws a `RangeError` if value is negative.
    */
@@ -35,6 +37,8 @@ export type NumberUtils = {
  * @public
  */
 export const NumberUtils: NumberUtils = {
+  isBigEndian,
+
   getNonnegativeInt32LE(source: Uint8Array, offset: number): number {
     if (source[offset + 3] > 127) {
       throw new RangeError(`Size cannot be negative at offset: ${offset}`);

package/src/utils/web_byte_utils.ts

@@ -100,7 +100,7 @@ export const webByteUtils = {
       return new Uint8Array(potentialUint8array);
     }
 
-    throw new BSONError(`Cannot make a Uint8Array from ${String(potentialUint8array)}`);
+    throw new BSONError(`Cannot make a Uint8Array from passed potentialBuffer.`);
   },
 
   allocate(size: number): Uint8Array {
@@ -193,5 +193,24 @@ export const webByteUtils = {
     return bytes.byteLength;
   },
 
-  randomBytes: webRandomBytes
+  randomBytes: webRandomBytes,
+
+  swap32(buffer: Uint8Array): Uint8Array {
+    if (buffer.length % 4 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 32-bits');
+    }
+
+    for (let i = 0; i < buffer.length; i += 4) {
+      const byte0 = buffer[i];
+      const byte1 = buffer[i + 1];
+      const byte2 = buffer[i + 2];
+      const byte3 = buffer[i + 3];
+      buffer[i] = byte3;
+      buffer[i + 1] = byte2;
+      buffer[i + 2] = byte1;
+      buffer[i + 3] = byte0;
+    }
+
+    return buffer;
+  }
 };