bson 6.10.3 → 7.0.0-alpha

package/package.json

@@ -14,7 +14,7 @@
     "vendor"
   ],
   "types": "bson.d.ts",
-  "version": "6.10.3",
+  "version": "7.0.0-alpha",
   "author": {
     "name": "The MongoDB NodeJS Team",
     "email": "dbx-node@mongodb.com"
@@ -27,40 +27,40 @@
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
-    "@microsoft/api-extractor": "^7.47.5",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^11.1.6",
+    "@microsoft/api-extractor": "^7.52.5",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
     "@types/chai": "^4.3.17",
     "@types/mocha": "^10.0.7",
-    "@types/node": "^22.1.0",
-    "@types/sinon": "^17.0.3",
+    "@types/node": "^24.2.1",
+    "@types/sinon": "^17.0.4",
     "@types/sinon-chai": "^3.2.12",
-    "@typescript-eslint/eslint-plugin": "^8.0.1",
-    "@typescript-eslint/parser": "^8.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.31.1",
+    "@typescript-eslint/parser": "^8.31.1",
     "benchmark": "^2.1.4",
     "chai": "^4.4.1",
     "chalk": "^5.3.0",
-    "dbx-js-tools": "github:mongodb-js/dbx-js-tools",
-    "eslint": "^9.8.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-no-bigint-usage": "file:etc/eslint/no-bigint-usage",
-    "eslint-plugin-prettier": "^5.2.1",
+    "dbx-js-tools": "github:mongodb-js/dbx-js-tools#main",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.2.6",
     "eslint-plugin-tsdoc": "^0.4.0",
     "magic-string": "^0.30.11",
-    "mocha": "^10.7.0",
+    "mocha": "^11.7.1",
     "node-fetch": "^3.3.2",
     "nyc": "^15.1.0",
-    "prettier": "^3.3.3",
-    "rollup": "^4.20.0",
+    "prettier": "^3.5.3",
+    "rollup": "^4.40.1",
     "sinon": "^18.0.0",
     "sinon-chai": "^3.7.0",
     "source-map-support": "^0.5.21",
     "tar": "^7.4.3",
     "ts-node": "^10.9.2",
-    "tsd": "^0.31.1",
-    "typescript": "^5.5.4",
+    "tsd": "^0.33.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.3",
     "typescript-cached-transpile": "0.0.6",
-    "uuid": "^10.0.0"
+    "uuid": "^11.1.0"
   },
   "tsd": {
     "directory": "test/types",
@@ -75,36 +75,36 @@
     "native": false
   },
   "main": "./lib/bson.cjs",
-  "module": "./lib/bson.mjs",
+  "module": "./lib/bson.node.mjs",
   "exports": {
-    "import": {
+    "browser": {
       "types": "./bson.d.ts",
       "default": "./lib/bson.mjs"
     },
-    "require": {
-      "types": "./bson.d.ts",
-      "default": "./lib/bson.cjs"
-    },
     "react-native": "./lib/bson.rn.cjs",
-    "browser": "./lib/bson.mjs"
+    "default": {
+      "types": "./bson.d.ts",
+      "import": "./lib/bson.node.mjs",
+      "require": "./lib/bson.cjs"
+    }
   },
   "compass:exports": {
     "import": "./lib/bson.cjs",
     "require": "./lib/bson.cjs"
   },
   "engines": {
-    "node": ">=16.20.1"
+    "node": ">=20.19.0"
   },
   "scripts": {
     "pretest": "npm run build",
-    "test": "npm run check:node && npm run check:web && npm run check:web-no-bigint",
+    "test": "npm run check:node && npm run check:web",
     "check:node": "WEB=false mocha test/node",
     "check:tsd": "npm run build:dts && tsd",
     "check:web": "WEB=true mocha test/node",
-    "check:web-no-bigint": "WEB=true NO_BIGINT=true mocha test/node",
-    "check:granular-bench": "npm run build:bench && node ./test/bench/etc/run_granular_benchmarks.js",
-    "check:spec-bench": "npm run build:bench && node ./test/bench/lib/spec/bsonBench.js",
-    "check:custom-bench": "npm run build && node ./test/bench/custom/main.mjs",
+    "check:granular-bench": "npm run build:bench && npm run check:baseline-bench && node ./test/bench/etc/run_granular_benchmarks.js",
+    "check:spec-bench": "npm run build:bench && npm run check:baseline-bench && node ./test/bench/lib/spec/bsonBench.js",
+    "check:custom-bench": "npm run build && npm run check:baseline-bench && node ./test/bench/custom/main.mjs",
+    "check:baseline-bench": "node ./test/bench/etc/cpuBaseline.js",
     "build:bench": "cd test/bench && npx tsc",
     "build:ts": "node ./node_modules/typescript/bin/tsc",
     "build:dts": "npm run build:ts && api-extractor run --typescript-compiler-folder node_modules/typescript --local && node etc/clean_definition_files.cjs",

package/src/binary.ts

@@ -45,7 +45,10 @@ export class Binary extends BSONValue {
   static readonly SUBTYPE_DEFAULT = 0;
   /** Function BSON type */
   static readonly SUBTYPE_FUNCTION = 1;
-  /** Byte Array BSON type */
+  /**
+   * Legacy default BSON Binary type
+   * @deprecated BSON Binary subtype 2 is deprecated in the BSON specification
+   */
   static readonly SUBTYPE_BYTE_ARRAY = 2;
   /** Deprecated UUID BSON type @deprecated Please use SUBTYPE_UUID */
   static readonly SUBTYPE_UUID_OLD = 3;
@@ -341,6 +344,8 @@ export class Binary extends BSONValue {
       throw new BSONError('Binary datatype field is not Int8');
     }
 
+    validateBinaryVector(this);
+
     return new Int8Array(
       this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position)
     );
@@ -361,6 +366,8 @@ export class Binary extends BSONValue {
       throw new BSONError('Binary datatype field is not Float32');
     }
 
+    validateBinaryVector(this);
+
     const floatBytes = new Uint8Array(
       this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position)
     );
@@ -387,6 +394,8 @@ export class Binary extends BSONValue {
       throw new BSONError('Binary datatype field is not packed bit');
     }
 
+    validateBinaryVector(this);
+
     return new Uint8Array(
       this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position)
     );
@@ -409,6 +418,8 @@ export class Binary extends BSONValue {
       throw new BSONError('Binary datatype field is not packed bit');
     }
 
+    validateBinaryVector(this);
+
     const byteCount = this.length() - 2;
     const bitCount = byteCount * 8 - this.buffer[1];
     const bits = new Int8Array(bitCount);
@@ -434,7 +445,9 @@ export class Binary extends BSONValue {
     buffer[1] = 0;
     const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
     buffer.set(intBytes, 2);
-    return new this(buffer, this.SUBTYPE_VECTOR);
+    const bin = new this(buffer, this.SUBTYPE_VECTOR);
+    validateBinaryVector(bin);
+    return bin;
   }
 
   /** Constructs a Binary representing an Float32 Vector. */
@@ -448,7 +461,9 @@ export class Binary extends BSONValue {
 
     if (NumberUtils.isBigEndian) ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2));
 
-    return new this(binaryBytes, this.SUBTYPE_VECTOR);
+    const bin = new this(binaryBytes, this.SUBTYPE_VECTOR);
+    validateBinaryVector(bin);
+    return bin;
   }
 
   /**
@@ -461,7 +476,9 @@ export class Binary extends BSONValue {
     buffer[0] = Binary.VECTOR_TYPE.PackedBit;
     buffer[1] = padding;
     buffer.set(array, 2);
-    return new this(buffer, this.SUBTYPE_VECTOR);
+    const bin = new this(buffer, this.SUBTYPE_VECTOR);
+    validateBinaryVector(bin);
+    return bin;
   }
 
   /**
@@ -517,6 +534,12 @@ export function validateBinaryVector(vector: Binary): void {
     throw new BSONError('Invalid Vector: padding must be zero for int8 and float32 vectors');
   }
 
+  if (datatype === Binary.VECTOR_TYPE.Float32) {
+    if (size !== 0 && size - 2 !== 0 && (size - 2) % 4 !== 0) {
+      throw new BSONError('Invalid Vector: Float32 vector must contain a multiple of 4 bytes');
+    }
+  }
+
   if (datatype === Binary.VECTOR_TYPE.PackedBit && padding !== 0 && size === 2) {
     throw new BSONError(
       'Invalid Vector: padding must be zero for packed bit vectors that are empty'

package/src/bson.ts

@@ -50,7 +50,7 @@ export {
   BSONRegExp,
   Decimal128
 };
-export { BSONValue } from './bson_value';
+export { BSONValue, bsonType, type BSONTypeTag } from './bson_value';
 export { BSONError, BSONVersionError, BSONRuntimeError, BSONOffsetError } from './error';
 export { BSONType } from './constants';
 export { EJSON } from './extended_json';

package/src/bson_value.ts

@@ -2,10 +2,33 @@ import { BSON_MAJOR_VERSION } from './constants';
 import { type InspectFn } from './parser/utils';
 import { BSON_VERSION_SYMBOL } from './constants';
 
+/** @public */
+export type BSONTypeTag =
+  | 'BSONRegExp'
+  | 'BSONSymbol'
+  | 'ObjectId'
+  | 'Binary'
+  | 'Decimal128'
+  | 'Double'
+  | 'Int32'
+  | 'Long'
+  | 'MaxKey'
+  | 'MinKey'
+  | 'Timestamp'
+  | 'Code'
+  | 'DBRef';
+
+/** @public */
+export const bsonType = Symbol.for('@@mdb.bson.type');
+
 /** @public */
 export abstract class BSONValue {
   /** @public */
-  public abstract get _bsontype(): string;
+  public abstract get _bsontype(): BSONTypeTag;
+
+  public get [bsonType](): this['_bsontype'] {
+    return this._bsontype;
+  }
 
   /** @internal */
   get [BSON_VERSION_SYMBOL](): typeof BSON_MAJOR_VERSION {

package/src/extended_json.ts

@@ -102,7 +102,6 @@ function deserializeValue(value: any, options: EJSONOptions = {}) {
       }
       if (in64BitRange) {
         if (options.useBigInt64) {
-          // eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true
           return BigInt(value);
         }
         return Long.fromNumber(value);
@@ -275,12 +274,10 @@ function serializeValue(value: any, options: EJSONSerializeOptions): any {
   }
 
   if (typeof value === 'bigint') {
-    /* eslint-disable no-restricted-globals -- This is allowed as we are accepting a bigint as input */
     if (!options.relaxed) {
       return { $numberLong: BigInt.asIntN(64, value).toString() };
     }
     return Number(BigInt.asIntN(64, value));
-    /* eslint-enable */
   }
 
   if (value instanceof RegExp || isRegExp(value)) {

package/src/long.ts

@@ -258,10 +258,8 @@ export class Long extends BSONValue {
    * @returns The corresponding Long value
    */
   static fromBigInt(value: bigint, unsigned?: boolean): Long {
-    // eslint-disable-next-line no-restricted-globals
-    const FROM_BIGINT_BIT_MASK = BigInt(0xffffffff);
-    // eslint-disable-next-line no-restricted-globals
-    const FROM_BIGINT_BIT_SHIFT = BigInt(32);
+    const FROM_BIGINT_BIT_MASK = 0xffffffffn;
+    const FROM_BIGINT_BIT_SHIFT = 32n;
     return new Long(
       Number(value & FROM_BIGINT_BIT_MASK),
       Number((value >> FROM_BIGINT_BIT_SHIFT) & FROM_BIGINT_BIT_MASK),
@@ -366,7 +364,7 @@ export class Long extends BSONValue {
     let unsigned = false;
     if (typeof unsignedOrRadix === 'number') {
       // For goog.math.long compatibility
-      (radix = unsignedOrRadix), (unsignedOrRadix = false);
+      ((radix = unsignedOrRadix), (unsignedOrRadix = false));
     } else {
       unsigned = !!unsignedOrRadix;
     }
@@ -456,7 +454,7 @@ export class Long extends BSONValue {
     let unsigned = false;
     if (typeof unsignedOrRadix === 'number') {
       // For goog.math.long compatibility
-      (radix = unsignedOrRadix), (unsignedOrRadix = false);
+      ((radix = unsignedOrRadix), (unsignedOrRadix = false));
     } else {
       unsigned = !!unsignedOrRadix;
     }
@@ -1077,7 +1075,6 @@ export class Long extends BSONValue {
 
   /** Converts the Long to a BigInt (arbitrary precision). */
   toBigInt(): bigint {
-    // eslint-disable-next-line no-restricted-globals -- This is allowed here as it is explicitly requesting a bigint
     return BigInt(this.toString());
   }
 
@@ -1223,10 +1220,8 @@ export class Long extends BSONValue {
     }
 
     if (useBigInt64) {
-      /* eslint-disable no-restricted-globals -- Can use BigInt here as useBigInt64=true */
       const bigIntResult = BigInt(doc.$numberLong);
       return BigInt.asIntN(64, bigIntResult);
-      /* eslint-enable */
     }
 
     const longResult = Long.fromString(doc.$numberLong);

package/src/objectid.ts

@@ -7,9 +7,6 @@ import { NumberUtils } from './utils/number_utils';
 // Unique sequence for the current process (initialized on first use)
 let PROCESS_UNIQUE: Uint8Array | null = null;
 
-/** ObjectId hexString cache @internal */
-const __idCache = new WeakMap(); // TODO(NODE-6549): convert this to #__id private field when target updated to ES2022
-
 /** @public */
 export interface ObjectIdLike {
   id: string | Uint8Array;
@@ -35,18 +32,22 @@ export class ObjectId extends BSONValue {
   /** @internal */
   private static index = Math.floor(Math.random() * 0xffffff);
 
-  static cacheHexString: boolean;
+  static cacheHexString: boolean = false;
 
   /** ObjectId Bytes @internal */
   private buffer!: Uint8Array;
 
   /**
-   * Create ObjectId from a number.
+   * If hex string caching is enabled, contains the cached hex string.  Otherwise, is null.
    *
-   * @param inputId - A number.
-   * @deprecated Instead, use `static createFromTime()` to set a numeric value for the new ObjectId.
+   * Note that #hexString is populated lazily, and as a result simply checking `this.#hexString != null` is
+   * not sufficient to determine if caching is enabled.  `ObjectId.prototype.isCached()` can be used to
+   * determine if the hex string has been cached yet for an ObjectId.
    */
-  constructor(inputId: number);
+  #cachedHexString: string | null = null;
+
+  /** To generate a new ObjectId, use ObjectId() with no argument. */
+  constructor();
   /**
    * Create ObjectId from a 24 character hex string.
    *
@@ -71,20 +72,18 @@ export class ObjectId extends BSONValue {
    * @param inputId - A 12 byte binary Buffer.
    */
   constructor(inputId: Uint8Array);
-  /** To generate a new ObjectId, use ObjectId() with no argument. */
-  constructor();
   /**
    * Implementation overload.
    *
    * @param inputId - All input types that are used in the constructor implementation.
    */
-  constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array);
+  constructor(inputId?: string | ObjectId | ObjectIdLike | Uint8Array);
   /**
    * Create a new ObjectId.
    *
    * @param inputId - An input value to create a new ObjectId from.
    */
-  constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array) {
+  constructor(inputId?: string | ObjectId | ObjectIdLike | Uint8Array) {
     super();
     // workingId is set based on type of input and whether valid id exists for the input
     let workingId;
@@ -102,19 +101,19 @@ export class ObjectId extends BSONValue {
     }
 
     // The following cases use workingId to construct an ObjectId
-    if (workingId == null || typeof workingId === 'number') {
+    if (workingId == null) {
       // The most common use case (blank id, new objectId instance)
       // Generate a new id
-      this.buffer = ObjectId.generate(typeof workingId === 'number' ? workingId : undefined);
+      this.buffer = ObjectId.generate();
     } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
-      // If intstanceof matches we can escape calling ensure buffer in Node.js environments
+      // If instanceof matches we can escape calling ensure buffer in Node.js environments
       this.buffer = ByteUtils.toLocalBufferType(workingId);
     } else if (typeof workingId === 'string') {
       if (ObjectId.validateHexString(workingId)) {
         this.buffer = ByteUtils.fromHex(workingId);
         // If we are caching the hex string
         if (ObjectId.cacheHexString) {
-          __idCache.set(this, workingId);
+          this.#cachedHexString = workingId;
         }
       } else {
         throw new BSONError(
@@ -137,7 +136,7 @@ export class ObjectId extends BSONValue {
   set id(value: Uint8Array) {
     this.buffer = value;
     if (ObjectId.cacheHexString) {
-      __idCache.set(this, ByteUtils.toHex(value));
+      this.#cachedHexString = ByteUtils.toHex(value);
     }
   }
 
@@ -166,15 +165,12 @@ export class ObjectId extends BSONValue {
 
   /** Returns the ObjectId id as a 24 lowercase character hex string representation */
   toHexString(): string {
-    if (ObjectId.cacheHexString) {
-      const __id = __idCache.get(this);
-      if (__id) return __id;
-    }
+    if (this.#cachedHexString) return this.#cachedHexString.toLowerCase();
 
     const hexString = ByteUtils.toHex(this.id);
 
     if (ObjectId.cacheHexString) {
-      __idCache.set(this, hexString);
+      this.#cachedHexString = hexString;
     }
 
     return hexString;
@@ -349,7 +345,7 @@ export class ObjectId extends BSONValue {
    * Checks if a value can be used to create a valid bson ObjectId
    * @param id - any JS value
    */
-  static isValid(id: string | number | ObjectId | ObjectIdLike | Uint8Array): boolean {
+  static isValid(id: string | ObjectId | ObjectIdLike | Uint8Array): boolean {
     if (id == null) return false;
     if (typeof id === 'string') return ObjectId.validateHexString(id);
 
@@ -372,9 +368,13 @@ export class ObjectId extends BSONValue {
     return new ObjectId(doc.$oid);
   }
 
-  /** @internal */
+  /**
+   * @internal
+   *
+   * used for testing
+   */
   private isCached(): boolean {
-    return ObjectId.cacheHexString && __idCache.has(this);
+    return ObjectId.cacheHexString && this.#cachedHexString != null;
   }
 
   /**

package/src/parser/on_demand/parse_to_elements.ts

@@ -9,29 +9,31 @@ import { NumberUtils } from '../../utils/number_utils';
  * - `minKey` is set to 255 so unsigned comparisons succeed
  * - Modify with caution, double check the bundle contains literals
  */
-const enum BSONElementType {
-  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 = 255,
-  maxKey = 127
-}
+const BSONElementType = {
+  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: 255,
+  maxKey: 127
+} as const;
+
+type BSONElementType = (typeof BSONElementType)[keyof typeof BSONElementType];
 
 /**
  * @public

package/src/timestamp.ts

@@ -1,10 +1,16 @@
+import { bsonType } from './bson_value';
 import { BSONError } from './error';
 import type { Int32 } from './int_32';
 import { Long } from './long';
 import { type InspectFn, defaultInspect } from './parser/utils';
 
 /** @public */
-export type TimestampOverrides = '_bsontype' | 'toExtendedJSON' | 'fromExtendedJSON' | 'inspect';
+export type TimestampOverrides =
+  | '_bsontype'
+  | 'toExtendedJSON'
+  | 'fromExtendedJSON'
+  | 'inspect'
+  | typeof bsonType;
 /** @public */
 export type LongWithoutOverrides = new (
   low: unknown,
@@ -35,6 +41,9 @@ export class Timestamp extends LongWithoutOverridesClass {
   get _bsontype(): 'Timestamp' {
     return 'Timestamp';
   }
+  get [bsonType](): 'Timestamp' {
+    return 'Timestamp';
+  }
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 

package/src/utils/node_byte_utils.ts

@@ -17,7 +17,7 @@ type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
   from(array: number[]): NodeJsBuffer;
   from(array: Uint8Array): NodeJsBuffer;
   from(array: ArrayBuffer): NodeJsBuffer;
-  from(array: ArrayBuffer, byteOffset: number, byteLength: number): NodeJsBuffer;
+  from(array: ArrayBufferLike, byteOffset: number, byteLength: number): NodeJsBuffer;
   from(base64: string, encoding: NodeJsEncoding): NodeJsBuffer;
   byteLength(input: string, encoding: 'utf8'): number;
   isBuffer(value: unknown): value is NodeJsBuffer;
@@ -26,34 +26,27 @@ type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
 // This can be nullish, but we gate the nodejs functions on being exported whether or not this exists
 // Node.js global
 declare const Buffer: NodeJsBufferConstructor;
-declare const require: (mod: 'crypto') => { randomBytes: (byteLength: number) => Uint8Array };
 
 /** @internal */
-export function nodejsMathRandomBytes(byteLength: number) {
+function nodejsMathRandomBytes(byteLength: number): NodeJsBuffer {
   return nodeJsByteUtils.fromNumberArray(
     Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))
   );
 }
 
-/**
- * @internal
- * WARNING: REQUIRE WILL BE REWRITTEN
- *
- * This code is carefully used by require_rewriter.mjs any modifications must be reflected in the plugin.
- *
- * @remarks
- * "crypto" is the only dependency BSON needs. This presents a problem for creating a bundle of the BSON library
- * in an es module format that can be used both on the browser and in Node.js. In Node.js when BSON is imported as
- * an es module, there will be no global require function defined, making the code below fallback to the much less desireable math.random bytes.
- * In order to make our es module bundle work as expected on Node.js we need to change this `require()` to a dynamic import, and the dynamic
- * import must be top-level awaited since es modules are async. So we rely on a custom rollup plugin to seek out the following lines of code
- * and replace `require` with `await import` and the IIFE line (`nodejsRandomBytes = (() => { ... })()`) with `nodejsRandomBytes = await (async () => { ... })()`
- * when generating an es module bundle.
- */
-const nodejsRandomBytes: (byteLength: number) => Uint8Array = (() => {
-  try {
-    return require('crypto').randomBytes;
-  } catch {
+/** @internal */
+function nodejsSecureRandomBytes(byteLength: number): NodeJsBuffer {
+  // @ts-expect-error: crypto.getRandomValues cannot actually be null here
+  return crypto.getRandomValues(nodeJsByteUtils.allocate(byteLength));
+}
+
+const nodejsRandomBytes = (() => {
+  const { crypto } = globalThis as {
+    crypto?: { getRandomValues?: (space: Uint8Array) => Uint8Array };
+  };
+  if (crypto != null && typeof crypto.getRandomValues === 'function') {
+    return nodejsSecureRandomBytes;
+  } else {
     return nodejsMathRandomBytes;
   }
 })();

package/src/utils/number_utils.ts

@@ -83,7 +83,6 @@ export const NumberUtils: NumberUtils = {
 
   /** Reads a little-endian 64-bit integer from source */
   getBigInt64LE(source: Uint8Array, offset: number): bigint {
-    // eslint-disable-next-line no-restricted-globals
     const hi = BigInt(
       source[offset + 4] +
         source[offset + 5] * 256 +
@@ -91,15 +90,14 @@ export const NumberUtils: NumberUtils = {
         (source[offset + 7] << 24)
     ); // Overflow
 
-    // eslint-disable-next-line no-restricted-globals
     const lo = BigInt(
       source[offset] +
         source[offset + 1] * 256 +
         source[offset + 2] * 65536 +
         source[offset + 3] * 16777216
     );
-    // eslint-disable-next-line no-restricted-globals
-    return (hi << BigInt(32)) + lo;
+
+    return (hi << 32n) + lo;
   },
 
   /** Reads a little-endian 64-bit float from source */
@@ -153,8 +151,7 @@ export const NumberUtils: NumberUtils = {
 
   /** Write a little-endian 64-bit integer to source */
   setBigInt64LE(destination: Uint8Array, offset: number, value: bigint): 8 {
-    /* eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true */
-    const mask32bits = BigInt(0xffff_ffff);
+    const mask32bits = 0xffff_ffffn;
 
     /** lower 32 bits */
     let lo = Number(value & mask32bits);
@@ -166,13 +163,7 @@ export const NumberUtils: NumberUtils = {
     lo >>= 8;
     destination[offset + 3] = lo;
 
-    /*
-       eslint-disable-next-line no-restricted-globals
-       -- This is allowed here as useBigInt64=true
-
-       upper 32 bits
-     */
-    let hi = Number((value >> BigInt(32)) & mask32bits);
+    let hi = Number((value >> 32n) & mask32bits);
     destination[offset + 4] = hi;
     hi >>= 8;
     destination[offset + 5] = hi;