bson 4.6.3 → 4.7.0

package/src/binary.ts

@@ -1,9 +1,10 @@
 import { Buffer } from 'buffer';
 import { ensureBuffer } from './ensure_buffer';
-import { uuidHexStringToBuffer } from './uuid_utils';
-import { UUID, UUIDExtended } from './uuid';
+import { bufferToUuidHexString, uuidHexStringToBuffer, uuidValidateString } from './uuid_utils';
+import { isUint8Array, randomBytes } from './parser/utils';
 import type { EJSONOptions } from './extended_json';
 import { BSONError, BSONTypeError } from './error';
+import { BSON_BINARY_SUBTYPE_UUID_NEW } from './constants';
 
 /** @public */
 export type BinarySequence = Uint8Array | Buffer | number[];
@@ -62,6 +63,13 @@ export class Binary {
   position!: number;
 
   /**
+   * Create a new Binary instance.
+   *
+   * This constructor can accept a string as its first argument. In this case,
+   * this string will be encoded using ISO-8859-1, **not** using UTF-8.
+   * This is almost certainly not what you want. Use `new Binary(Buffer.from(string))`
+   * instead to convert the string to a Buffer using UTF-8 first.
+   *
    * @param buffer - a buffer object containing the binary data.
    * @param subType - the option binary type.
    */
@@ -270,7 +278,7 @@ export class Binary {
     if (!data) {
       throw new BSONTypeError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
     }
-    return new Binary(data, type);
+    return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);
   }
 
   /** @internal */
@@ -285,3 +293,189 @@ export class Binary {
 }
 
 Object.defineProperty(Binary.prototype, '_bsontype', { value: 'Binary' });
+
+/** @public */
+export type UUIDExtended = {
+  $uuid: string;
+};
+const UUID_BYTE_LENGTH = 16;
+
+/**
+ * A class representation of the BSON UUID type.
+ * @public
+ */
+export class UUID extends Binary {
+  static cacheHexString: boolean;
+
+  /** UUID hexString cache @internal */
+  private __id?: string;
+
+  /**
+   * Create an UUID type
+   *
+   * @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;
+    let hexStr;
+    if (input == null) {
+      bytes = UUID.generate();
+    } else if (input instanceof UUID) {
+      bytes = Buffer.from(input.buffer);
+      hexStr = input.__id;
+    } else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
+      bytes = ensureBuffer(input);
+    } else if (typeof input === 'string') {
+      bytes = uuidHexStringToBuffer(input);
+    } else {
+      throw new BSONTypeError(
+        'Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).'
+      );
+    }
+    super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);
+    this.__id = hexStr;
+  }
+
+  /**
+   * The UUID bytes
+   * @readonly
+   */
+  get id(): Buffer {
+    return this.buffer;
+  }
+
+  set id(value: Buffer) {
+    this.buffer = value;
+
+    if (UUID.cacheHexString) {
+      this.__id = bufferToUuidHexString(value);
+    }
+  }
+
+  /**
+   * Returns the UUID id as a 32 or 36 character hex string representation, excluding/including dashes (defaults to 36 character dash separated)
+   * @param includeDashes - should the string exclude dash-separators.
+   * */
+  toHexString(includeDashes = true): string {
+    if (UUID.cacheHexString && this.__id) {
+      return this.__id;
+    }
+
+    const uuidHexString = bufferToUuidHexString(this.id, includeDashes);
+
+    if (UUID.cacheHexString) {
+      this.__id = uuidHexString;
+    }
+
+    return uuidHexString;
+  }
+
+  /**
+   * 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();
+  }
+
+  /**
+   * Converts the id into its JSON string representation.
+   * A 36 character (dashes included) hex string in the format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+   */
+  toJSON(): string {
+    return this.toHexString();
+  }
+
+  /**
+   * Compares the equality of this UUID with `otherID`.
+   *
+   * @param otherId - UUID instance to compare against.
+   */
+  equals(otherId: string | Buffer | UUID): boolean {
+    if (!otherId) {
+      return false;
+    }
+
+    if (otherId instanceof UUID) {
+      return otherId.id.equals(this.id);
+    }
+
+    try {
+      return new UUID(otherId).id.equals(this.id);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Creates a Binary instance from the current UUID.
+   */
+  toBinary(): Binary {
+    return new Binary(this.id, Binary.SUBTYPE_UUID);
+  }
+
+  /**
+   * Generates a populated buffer containing a v4 uuid
+   */
+  static generate(): Buffer {
+    const bytes = 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);
+  }
+
+  /**
+   * Checks if a value is a valid bson UUID
+   * @param input - UUID, string or Buffer to validate.
+   */
+  static isValid(input: string | Buffer | UUID): boolean {
+    if (!input) {
+      return false;
+    }
+
+    if (input instanceof UUID) {
+      return true;
+    }
+
+    if (typeof input === 'string') {
+      return uuidValidateString(input);
+    }
+
+    if (isUint8Array(input)) {
+      // check for length & uuid version (https://tools.ietf.org/html/rfc4122#section-4.1.3)
+      if (input.length !== UUID_BYTE_LENGTH) {
+        return false;
+      }
+
+      return (input[6] & 0xf0) === 0x40 && (input[8] & 0x80) === 0x80;
+    }
+
+    return false;
+  }
+
+  /**
+   * Creates an UUID from a hex string representation of an UUID.
+   * @param hexString - 32 or 36 character hex string (dashes excluded/included).
+   */
+  static createFromHexString(hexString: string): UUID {
+    const buffer = uuidHexStringToBuffer(hexString);
+    return new UUID(buffer);
+  }
+
+  /**
+   * Converts to a string representation of this Id.
+   *
+   * @returns return the 36 character hex string representation.
+   * @internal
+   */
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return this.inspect();
+  }
+
+  inspect(): string {
+    return `new UUID("${this.toHexString()}")`;
+  }
+}

package/src/bson.ts

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import { Binary } from './binary';
+import { Binary, UUID } from './binary';
 import { Code } from './code';
 import { DBRef } from './db_ref';
 import { Decimal128 } from './decimal128';
@@ -20,9 +20,8 @@ import { serializeInto as internalSerialize, SerializeOptions } from './parser/s
 import { BSONRegExp } from './regexp';
 import { BSONSymbol } from './symbol';
 import { Timestamp } from './timestamp';
-import { UUID } from './uuid';
-export { BinaryExtended, BinaryExtendedLegacy, BinarySequence } from './binary';
-export { CodeExtended } from './code';
+export type { UUIDExtended, BinaryExtended, BinaryExtendedLegacy, BinarySequence } from './binary';
+export type { CodeExtended } from './code';
 export {
   BSON_BINARY_SUBTYPE_BYTE_ARRAY,
   BSON_BINARY_SUBTYPE_DEFAULT,
@@ -59,25 +58,21 @@ export {
   BSON_INT64_MAX,
   BSON_INT64_MIN
 } from './constants';
-export { DBRefLike } from './db_ref';
-export { Decimal128Extended } from './decimal128';
-export { DoubleExtended } from './double';
-export { EJSON, EJSONOptions } from './extended_json';
-export { Int32Extended } from './int_32';
-export { LongExtended } from './long';
-export { MaxKeyExtended } from './max_key';
-export { MinKeyExtended } from './min_key';
-export { ObjectIdExtended, ObjectIdLike } from './objectid';
-export { BSONRegExpExtended, BSONRegExpExtendedLegacy } from './regexp';
-export { BSONSymbolExtended } from './symbol';
-export {
-  LongWithoutOverrides,
-  LongWithoutOverridesClass,
-  TimestampExtended,
-  TimestampOverrides
-} from './timestamp';
-export { UUIDExtended } from './uuid';
-export { SerializeOptions, DeserializeOptions };
+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';
+export type { MinKeyExtended } from './min_key';
+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 { SerializeOptions, DeserializeOptions };
 export {
   Code,
   Map,

package/src/code.ts

@@ -52,7 +52,7 @@ export class Code {
 
   inspect(): string {
     const codeJson = this.toJSON();
-    return `new Code("${codeJson.code}"${
+    return `new Code("${String(codeJson.code)}"${
       codeJson.scope ? `, ${JSON.stringify(codeJson.scope)}` : ''
     })`;
   }

package/src/db_ref.ts

@@ -115,7 +115,7 @@ export class DBRef {
     // NOTE: if OID is an ObjectId class it will just print the oid string.
     const oid =
       this.oid === undefined || this.oid.toString === undefined ? this.oid : this.oid.toString();
-    return `new DBRef("${this.namespace}", new ObjectId("${oid}")${
+    return `new DBRef("${this.namespace}", new ObjectId("${String(oid)}")${
       this.db ? `, "${this.db}"` : ''
     })`;
   }

package/src/decimal128.ts

@@ -690,8 +690,8 @@ export class Decimal128 {
       // representation should be treated as 0/-0" spec cases in decimal128-1.json)
       if (significand_digits > 34) {
         string.push(`${0}`);
-        if (exponent > 0) string.push('E+' + exponent);
-        else if (exponent < 0) string.push('E' + exponent);
+        if (exponent > 0) string.push(`E+${exponent}`);
+        else if (exponent < 0) string.push(`E${exponent}`);
         return string.join('');
       }
 
@@ -709,7 +709,7 @@ export class Decimal128 {
       // Exponent
       string.push('E');
       if (scientific_exponent > 0) {
-        string.push('+' + scientific_exponent);
+        string.push(`+${scientific_exponent}`);
       } else {
         string.push(`${scientific_exponent}`);
       }

package/src/extended_json.ts

@@ -44,7 +44,8 @@ export function isBSONType(value: unknown): value is BSONType {
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
 // INT64 boundaries
-const BSON_INT64_MAX = 0x7fffffffffffffff;
+// 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
@@ -284,7 +285,17 @@ function serializeDocument(doc: any, options: EJSONSerializeOptions) {
     for (const name in doc) {
       options.seenObjects.push({ propertyName: name, obj: null });
       try {
-        _doc[name] = serializeValue(doc[name], options);
+        const value = serializeValue(doc[name], options);
+        if (name === '__proto__') {
+          Object.defineProperty(_doc, name, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true
+          });
+        } else {
+          _doc[name] = value;
+        }
       } finally {
         options.seenObjects.pop();
       }

package/src/long.ts

@@ -4,12 +4,37 @@ import type { Timestamp } from './timestamp';
 
 interface LongWASMHelpers {
   /** Gets the high bits of the last operation performed */
-  get_high(): number;
-  div_u(lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number): number;
-  div_s(lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number): number;
-  rem_u(lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number): number;
-  rem_s(lowBits: number, highBits: number, lowBitsDivisor: number, highBitsDivisor: number): number;
+  get_high(this: void): number;
+  div_u(
+    this: void,
+    lowBits: number,
+    highBits: number,
+    lowBitsDivisor: number,
+    highBitsDivisor: number
+  ): number;
+  div_s(
+    this: void,
+    lowBits: number,
+    highBits: number,
+    lowBitsDivisor: number,
+    highBitsDivisor: number
+  ): number;
+  rem_u(
+    this: void,
+    lowBits: number,
+    highBits: number,
+    lowBitsDivisor: number,
+    highBitsDivisor: number
+  ): number;
+  rem_s(
+    this: void,
+    lowBits: number,
+    highBits: number,
+    lowBitsDivisor: number,
+    highBitsDivisor: number
+  ): number;
   mul(
+    this: void,
     lowBits: number,
     highBits: number,
     lowBitsMultiplier: number,
@@ -306,8 +331,7 @@ export class Long {
   /**
    * Tests if the specified object is a Long.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  static isLong(value: any): value is Long {
+  static isLong(value: unknown): value is Long {
     return isObjectLike(value) && value['__isLong__'] === true;
   }
 
@@ -471,6 +495,7 @@ export class Long {
     // into the result, and subtract it from the remainder.  It is critical that
     // the approximate value is less than or equal to the real value so that the
     // remainder never becomes negative.
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
     rem = this;
     while (rem.gte(divisor)) {
       // Approximate the result of division. This may be a little greater or

package/src/objectid.ts

@@ -37,7 +37,7 @@ export class ObjectId {
   static cacheHexString: boolean;
 
   /** ObjectId Bytes @internal */
-  private [kId]: Buffer;
+  private [kId]!: Buffer;
   /** ObjectId hexString cache @internal */
   private __id?: string;
 
@@ -72,7 +72,8 @@ export class ObjectId {
       // Generate a new id
       this[kId] = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
     } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
-      this[kId] = ensureBuffer(workingId);
+      // If intstanceof matches we can escape calling ensure buffer in Node.js environments
+      this[kId] = workingId instanceof Buffer ? workingId : ensureBuffer(workingId);
     } else if (typeof workingId === 'string') {
       if (workingId.length === 12) {
         const bytes = Buffer.from(workingId);

package/src/parser/calculate_size.ts

@@ -121,15 +121,16 @@ function calculateElement(
           );
         }
       } else if (value['_bsontype'] === 'Binary') {
+        const binary: Binary = value;
         // Check what kind of subtype we have
-        if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
+        if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
           return (
             (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
-            (value.position + 1 + 4 + 1 + 4)
+            (binary.position + 1 + 4 + 1 + 4)
           );
         } else {
           return (
-            (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1)
+            (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (binary.position + 1 + 4 + 1)
           );
         }
       } else if (value['_bsontype'] === 'Symbol') {

package/src/parser/deserializer.ts

@@ -197,6 +197,7 @@ function deserializeObject(
   let isPossibleDBRef = isArray ? false : null;
 
   // While we have more left data left keep parsing
+  const dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   while (!done) {
     // Read the type
     const elementType = buffer[index++];
@@ -263,10 +264,10 @@ function deserializeObject(
         (buffer[index++] << 16) |
         (buffer[index++] << 24);
     } else if (elementType === constants.BSON_DATA_NUMBER && promoteValues === false) {
-      value = new Double(buffer.readDoubleLE(index));
+      value = new Double(dataview.getFloat64(index, true));
       index = index + 8;
     } else if (elementType === constants.BSON_DATA_NUMBER) {
-      value = buffer.readDoubleLE(index);
+      value = dataview.getFloat64(index, true);
       index = index + 8;
     } else if (elementType === constants.BSON_DATA_DATE) {
       const lowBits =
@@ -416,6 +417,9 @@ function deserializeObject(
           value = buffer.slice(index, index + binarySize);
         } else {
           value = new Binary(buffer.slice(index, index + binarySize), subType);
+          if (subType === constants.BSON_BINARY_SUBTYPE_UUID_NEW) {
+            value = value.toUUID();
+          }
         }
       } else {
         const _buffer = Buffer.alloc(binarySize);
@@ -441,8 +445,10 @@ function deserializeObject(
 
         if (promoteBuffers && promoteValues) {
           value = _buffer;
+        } else if (subType === constants.BSON_BINARY_SUBTYPE_UUID_NEW) {
+          value = new Binary(buffer.slice(index, index + binarySize), subType).toUUID();
         } else {
-          value = new Binary(_buffer, subType);
+          value = new Binary(buffer.slice(index, index + binarySize), subType);
         }
       }
 
@@ -697,7 +703,7 @@ function deserializeObject(
       value = new DBRef(namespace, oid);
     } else {
       throw new BSONError(
-        'Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname "' + name + '"'
+        `Detected unknown BSON type ${elementType.toString(16)} for fieldname "${name}"`
       );
     }
     if (name === '__proto__') {
@@ -742,9 +748,11 @@ function isolateEval(
   functionCache?: { [hash: string]: Function },
   object?: Document
 ) {
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
   if (!functionCache) return new Function(functionString);
   // Check for cache hit, eval if missing and return cached function
   if (functionCache[functionString] == null) {
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
     functionCache[functionString] = new Function(functionString);
   }
 

package/src/parser/serializer.ts

@@ -9,7 +9,6 @@ import type { Double } from '../double';
 import { ensureBuffer } from '../ensure_buffer';
 import { BSONError, BSONTypeError } from '../error';
 import { isBSONType } from '../extended_json';
-import { writeIEEE754 } from '../float_parser';
 import type { Int32 } from '../int_32';
 import { Long } from '../long';
 import { Map } from '../map';
@@ -79,6 +78,12 @@ function serializeString(
   return index;
 }
 
+const SPACE_FOR_FLOAT64 = new Uint8Array(8);
+const DV_FOR_FLOAT64 = new DataView(
+  SPACE_FOR_FLOAT64.buffer,
+  SPACE_FOR_FLOAT64.byteOffset,
+  SPACE_FOR_FLOAT64.byteLength
+);
 function serializeNumber(
   buffer: Buffer,
   key: string,
@@ -119,7 +124,8 @@ function serializeNumber(
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
     // Write float
-    writeIEEE754(buffer, value, index, 'little', 52, 8);
+    DV_FOR_FLOAT64.setFloat64(0, value, true);
+    buffer.set(SPACE_FOR_FLOAT64, index);
     // Adjust index
     index = index + 8;
   }
@@ -487,7 +493,8 @@ function serializeDouble(
   buffer[index++] = 0;
 
   // Write float
-  writeIEEE754(buffer, value.value, index, 'little', 52, 8);
+  DV_FOR_FLOAT64.setFloat64(0, value.value, true);
+  buffer.set(SPACE_FOR_FLOAT64, index);
 
   // Adjust index
   index = index + 8;
@@ -763,7 +770,7 @@ export function serializeInto(
   if (Array.isArray(object)) {
     // Get object keys
     for (let i = 0; i < object.length; i++) {
-      const key = '' + i;
+      const key = `${i}`;
       let value = object[i];
 
       // Is there an override value
@@ -841,7 +848,7 @@ export function serializeInto(
       } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index, true);
       } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value['_bsontype'])}`);
       }
     }
   } else if (object instanceof Map || isMap(object)) {
@@ -942,7 +949,7 @@ export function serializeInto(
       } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value['_bsontype'])}`);
       }
     }
   } else {
@@ -1047,7 +1054,7 @@ export function serializeInto(
       } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+        throw new BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value['_bsontype'])}`);
       }
     }
   }

package/src/parser/utils.ts

@@ -33,33 +33,37 @@ declare let window: any;
 declare let require: Function;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare let global: any;
-declare const self: unknown;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare let process: any; // Used by @rollup/plugin-replace
 
 const detectRandomBytes = (): RandomBytesFunction => {
-  if (typeof window !== 'undefined') {
-    // browser crypto implementation(s)
-    const target = window.crypto || window.msCrypto; // allow for IE11
-    if (target && target.getRandomValues) {
-      return size => target.getRandomValues(Buffer.alloc(size));
+  if (process.browser) {
+    if (typeof window !== 'undefined') {
+      // browser crypto implementation(s)
+      const target = window.crypto || window.msCrypto; // allow for IE11
+      if (target && target.getRandomValues) {
+        return size => target.getRandomValues(Buffer.alloc(size));
+      }
     }
-  }
 
-  if (typeof global !== 'undefined' && global.crypto && global.crypto.getRandomValues) {
-    // allow for RN packages such as https://www.npmjs.com/package/react-native-get-random-values to populate global
-    return size => global.crypto.getRandomValues(Buffer.alloc(size));
-  }
+    if (typeof global !== 'undefined' && global.crypto && global.crypto.getRandomValues) {
+      // allow for RN packages such as https://www.npmjs.com/package/react-native-get-random-values to populate global
+      return size => global.crypto.getRandomValues(Buffer.alloc(size));
+    }
 
-  let requiredRandomBytes: RandomBytesFunction | null | undefined;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    requiredRandomBytes = require('crypto').randomBytes;
-  } catch (e) {
-    // keep the fallback
-  }
+    return insecureRandomBytes;
+  } else {
+    let requiredRandomBytes: RandomBytesFunction | null | undefined;
+    try {
+      requiredRandomBytes = require('crypto').randomBytes;
+    } catch (e) {
+      // keep the fallback
+    }
 
-  // NOTE: in transpiled cases the above require might return null/undefined
+    // NOTE: in transpiled cases the above require might return null/undefined
 
-  return requiredRandomBytes || insecureRandomBytes;
+    return requiredRandomBytes || insecureRandomBytes;
+  }
 };
 
 export const randomBytes = detectRandomBytes();

package/src/timestamp.ts

@@ -44,7 +44,7 @@ export class Timestamp extends LongWithoutOverridesClass {
   constructor(low: number, high: number);
   constructor(low: number | Long | { t: number; i: number }, high?: number) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    ///@ts-expect-error
+    // @ts-expect-error
     if (!(this instanceof Timestamp)) return new Timestamp(low, high);
 
     if (Long.isLong(low)) {