@adobe-commerce/aio-toolkit 1.2.1 → 1.2.2

package/dist/index.mjs

@@ -2190,8 +2190,8 @@ var _FileRepository = class _FileRepository {
     const existingFiles = await this.metadata();
     if (existingFiles.length) {
       for (const file of existingFiles) {
-        const buffer = await filesLib.read(`${file.name}`);
-        const data = JSON.parse(buffer.toString());
+        const buffer2 = await filesLib.read(`${file.name}`);
+        const data = JSON.parse(buffer2.toString());
         results.push({
           ...data,
           createdAt: file.creationTime.toISOString(),
@@ -2225,8 +2225,8 @@ var _FileRepository = class _FileRepository {
     const filesLib = await this.getFiles();
     const existingFile = await filesLib.list(filepath);
     if (existingFile.length) {
-      const buffer = await filesLib.read(filepath);
-      const data = JSON.parse(buffer.toString());
+      const buffer2 = await filesLib.read(filepath);
+      const data = JSON.parse(buffer2.toString());
       const fileProps = await filesLib.getProperties(filepath);
       return {
         ...data,
@@ -2266,8 +2266,8 @@ var _FileRepository = class _FileRepository {
             ...payload
           };
         } else {
-          const buffer = await filesLib.read(filepath);
-          const existingData = JSON.parse(buffer.toString());
+          const buffer2 = await filesLib.read(filepath);
+          const existingData = JSON.parse(buffer2.toString());
           payload = { ...existingData, ...payload };
         }
       } else {
@@ -2326,6 +2326,3177 @@ __name(_FileRepository, "FileRepository");
 var FileRepository = _FileRepository;
 var file_repository_default = FileRepository;
 
+// node_modules/bson/lib/bson.node.mjs
+import { randomBytes } from "crypto";
+var TypedArrayPrototypeGetSymbolToStringTag = (() => {
+  const g = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get;
+  return (value) => g.call(value);
+})();
+function isUint8Array(value) {
+  return TypedArrayPrototypeGetSymbolToStringTag(value) === "Uint8Array";
+}
+__name(isUint8Array, "isUint8Array");
+function isAnyArrayBuffer(value) {
+  return typeof value === "object" && value != null && Symbol.toStringTag in value && (value[Symbol.toStringTag] === "ArrayBuffer" || value[Symbol.toStringTag] === "SharedArrayBuffer");
+}
+__name(isAnyArrayBuffer, "isAnyArrayBuffer");
+function isRegExp(regexp) {
+  return regexp instanceof RegExp || Object.prototype.toString.call(regexp) === "[object RegExp]";
+}
+__name(isRegExp, "isRegExp");
+function isMap(value) {
+  return typeof value === "object" && value != null && Symbol.toStringTag in value && value[Symbol.toStringTag] === "Map";
+}
+__name(isMap, "isMap");
+function isDate(date) {
+  return date instanceof Date || Object.prototype.toString.call(date) === "[object Date]";
+}
+__name(isDate, "isDate");
+function defaultInspect(x, _options) {
+  return JSON.stringify(x, (k, v) => {
+    if (typeof v === "bigint") {
+      return { $numberLong: `${v}` };
+    } else if (isMap(v)) {
+      return Object.fromEntries(v);
+    }
+    return v;
+  });
+}
+__name(defaultInspect, "defaultInspect");
+function getStylizeFunction(options) {
+  const stylizeExists = options != null && typeof options === "object" && "stylize" in options && typeof options.stylize === "function";
+  if (stylizeExists) {
+    return options.stylize;
+  }
+}
+__name(getStylizeFunction, "getStylizeFunction");
+var BSON_MAJOR_VERSION = 6;
+var BSON_VERSION_SYMBOL = /* @__PURE__ */ Symbol.for("@@mdb.bson.version");
+var BSON_INT32_MAX = 2147483647;
+var BSON_INT32_MIN = -2147483648;
+var BSON_INT64_MAX = Math.pow(2, 63) - 1;
+var BSON_INT64_MIN = -Math.pow(2, 63);
+var JS_INT_MAX = Math.pow(2, 53);
+var JS_INT_MIN = -Math.pow(2, 53);
+var BSON_BINARY_SUBTYPE_UUID_NEW = 4;
+var 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
+});
+var _BSONError = class _BSONError extends Error {
+  get bsonError() {
+    return true;
+  }
+  get name() {
+    return "BSONError";
+  }
+  constructor(message, options) {
+    super(message, options);
+  }
+  static isBSONError(value) {
+    return value != null && typeof value === "object" && "bsonError" in value && value.bsonError === true && "name" in value && "message" in value && "stack" in value;
+  }
+};
+__name(_BSONError, "BSONError");
+var BSONError = _BSONError;
+var _BSONVersionError = class _BSONVersionError extends BSONError {
+  get name() {
+    return "BSONVersionError";
+  }
+  constructor() {
+    super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.x.x`);
+  }
+};
+__name(_BSONVersionError, "BSONVersionError");
+var BSONVersionError = _BSONVersionError;
+var _BSONRuntimeError = class _BSONRuntimeError extends BSONError {
+  get name() {
+    return "BSONRuntimeError";
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+__name(_BSONRuntimeError, "BSONRuntimeError");
+var BSONRuntimeError = _BSONRuntimeError;
+var _BSONOffsetError = class _BSONOffsetError extends BSONError {
+  get name() {
+    return "BSONOffsetError";
+  }
+  constructor(message, offset, options) {
+    super(`${message}. offset: ${offset}`, options);
+    this.offset = offset;
+  }
+};
+__name(_BSONOffsetError, "BSONOffsetError");
+var BSONOffsetError = _BSONOffsetError;
+var TextDecoderFatal;
+var TextDecoderNonFatal;
+function parseUtf8(buffer2, start, end, fatal) {
+  if (fatal) {
+    TextDecoderFatal ?? (TextDecoderFatal = new TextDecoder("utf8", { fatal: true }));
+    try {
+      return TextDecoderFatal.decode(buffer2.subarray(start, end));
+    } catch (cause) {
+      throw new BSONError("Invalid UTF-8 string in BSON document", { cause });
+    }
+  }
+  TextDecoderNonFatal ?? (TextDecoderNonFatal = new TextDecoder("utf8", { fatal: false }));
+  return TextDecoderNonFatal.decode(buffer2.subarray(start, end));
+}
+__name(parseUtf8, "parseUtf8");
+function tryReadBasicLatin(uint8array, start, end) {
+  if (uint8array.length === 0) {
+    return "";
+  }
+  const stringByteLength = end - start;
+  if (stringByteLength === 0) {
+    return "";
+  }
+  if (stringByteLength > 20) {
+    return null;
+  }
+  if (stringByteLength === 1 && uint8array[start] < 128) {
+    return String.fromCharCode(uint8array[start]);
+  }
+  if (stringByteLength === 2 && uint8array[start] < 128 && uint8array[start + 1] < 128) {
+    return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]);
+  }
+  if (stringByteLength === 3 && uint8array[start] < 128 && uint8array[start + 1] < 128 && uint8array[start + 2] < 128) {
+    return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]) + String.fromCharCode(uint8array[start + 2]);
+  }
+  const latinBytes = [];
+  for (let i = start; i < end; i++) {
+    const byte = uint8array[i];
+    if (byte > 127) {
+      return null;
+    }
+    latinBytes.push(byte);
+  }
+  return String.fromCharCode(...latinBytes);
+}
+__name(tryReadBasicLatin, "tryReadBasicLatin");
+function tryWriteBasicLatin(destination, source, offset) {
+  if (source.length === 0)
+    return 0;
+  if (source.length > 25)
+    return null;
+  if (destination.length - offset < source.length)
+    return null;
+  for (let charOffset = 0, destinationOffset = offset; charOffset < source.length; charOffset++, destinationOffset++) {
+    const char = source.charCodeAt(charOffset);
+    if (char > 127)
+      return null;
+    destination[destinationOffset] = char;
+  }
+  return source.length;
+}
+__name(tryWriteBasicLatin, "tryWriteBasicLatin");
+var nodeJsByteUtils = {
+  toLocalBufferType(potentialBuffer) {
+    if (Buffer.isBuffer(potentialBuffer)) {
+      return potentialBuffer;
+    }
+    if (ArrayBuffer.isView(potentialBuffer)) {
+      return Buffer.from(potentialBuffer.buffer, potentialBuffer.byteOffset, potentialBuffer.byteLength);
+    }
+    const stringTag = potentialBuffer?.[Symbol.toStringTag] ?? Object.prototype.toString.call(potentialBuffer);
+    if (stringTag === "ArrayBuffer" || stringTag === "SharedArrayBuffer" || stringTag === "[object ArrayBuffer]" || stringTag === "[object SharedArrayBuffer]") {
+      return Buffer.from(potentialBuffer);
+    }
+    throw new BSONError(`Cannot create Buffer from the passed potentialBuffer.`);
+  },
+  allocate(size) {
+    return Buffer.alloc(size);
+  },
+  allocateUnsafe(size) {
+    return Buffer.allocUnsafe(size);
+  },
+  equals(a, b) {
+    return nodeJsByteUtils.toLocalBufferType(a).equals(b);
+  },
+  fromNumberArray(array) {
+    return Buffer.from(array);
+  },
+  fromBase64(base64) {
+    return Buffer.from(base64, "base64");
+  },
+  toBase64(buffer2) {
+    return nodeJsByteUtils.toLocalBufferType(buffer2).toString("base64");
+  },
+  fromISO88591(codePoints) {
+    return Buffer.from(codePoints, "binary");
+  },
+  toISO88591(buffer2) {
+    return nodeJsByteUtils.toLocalBufferType(buffer2).toString("binary");
+  },
+  fromHex(hex) {
+    return Buffer.from(hex, "hex");
+  },
+  toHex(buffer2) {
+    return nodeJsByteUtils.toLocalBufferType(buffer2).toString("hex");
+  },
+  toUTF8(buffer2, start, end, fatal) {
+    const basicLatin = end - start <= 20 ? tryReadBasicLatin(buffer2, start, end) : null;
+    if (basicLatin != null) {
+      return basicLatin;
+    }
+    const string = nodeJsByteUtils.toLocalBufferType(buffer2).toString("utf8", start, end);
+    if (fatal) {
+      for (let i = 0; i < string.length; i++) {
+        if (string.charCodeAt(i) === 65533) {
+          parseUtf8(buffer2, start, end, true);
+          break;
+        }
+      }
+    }
+    return string;
+  },
+  utf8ByteLength(input) {
+    return Buffer.byteLength(input, "utf8");
+  },
+  encodeUTF8Into(buffer2, source, byteOffset) {
+    const latinBytesWritten = tryWriteBasicLatin(buffer2, source, byteOffset);
+    if (latinBytesWritten != null) {
+      return latinBytesWritten;
+    }
+    return nodeJsByteUtils.toLocalBufferType(buffer2).write(source, byteOffset, void 0, "utf8");
+  },
+  randomBytes,
+  swap32(buffer2) {
+    return nodeJsByteUtils.toLocalBufferType(buffer2).swap32();
+  }
+};
+function isReactNative() {
+  const { navigator } = globalThis;
+  return typeof navigator === "object" && navigator.product === "ReactNative";
+}
+__name(isReactNative, "isReactNative");
+function webMathRandomBytes(byteLength) {
+  if (byteLength < 0) {
+    throw new RangeError(`The argument 'byteLength' is invalid. Received ${byteLength}`);
+  }
+  return webByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
+}
+__name(webMathRandomBytes, "webMathRandomBytes");
+var webRandomBytes = (() => {
+  const { crypto: crypto4 } = globalThis;
+  if (crypto4 != null && typeof crypto4.getRandomValues === "function") {
+    return (byteLength) => {
+      return crypto4.getRandomValues(webByteUtils.allocate(byteLength));
+    };
+  } else {
+    if (isReactNative()) {
+      const { console: console2 } = globalThis;
+      console2?.warn?.("BSON: For React Native please polyfill crypto.getRandomValues, e.g. using: https://www.npmjs.com/package/react-native-get-random-values.");
+    }
+    return webMathRandomBytes;
+  }
+})();
+var HEX_DIGIT = /(\d|[a-f])/i;
+var webByteUtils = {
+  toLocalBufferType(potentialUint8array) {
+    const stringTag = potentialUint8array?.[Symbol.toStringTag] ?? Object.prototype.toString.call(potentialUint8array);
+    if (stringTag === "Uint8Array") {
+      return potentialUint8array;
+    }
+    if (ArrayBuffer.isView(potentialUint8array)) {
+      return new Uint8Array(potentialUint8array.buffer.slice(potentialUint8array.byteOffset, potentialUint8array.byteOffset + potentialUint8array.byteLength));
+    }
+    if (stringTag === "ArrayBuffer" || stringTag === "SharedArrayBuffer" || stringTag === "[object ArrayBuffer]" || stringTag === "[object SharedArrayBuffer]") {
+      return new Uint8Array(potentialUint8array);
+    }
+    throw new BSONError(`Cannot make a Uint8Array from passed potentialBuffer.`);
+  },
+  allocate(size) {
+    if (typeof size !== "number") {
+      throw new TypeError(`The "size" argument must be of type number. Received ${String(size)}`);
+    }
+    return new Uint8Array(size);
+  },
+  allocateUnsafe(size) {
+    return webByteUtils.allocate(size);
+  },
+  equals(a, b) {
+    if (a.byteLength !== b.byteLength) {
+      return false;
+    }
+    for (let i = 0; i < a.byteLength; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  },
+  fromNumberArray(array) {
+    return Uint8Array.from(array);
+  },
+  fromBase64(base64) {
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  },
+  toBase64(uint8array) {
+    return btoa(webByteUtils.toISO88591(uint8array));
+  },
+  fromISO88591(codePoints) {
+    return Uint8Array.from(codePoints, (c) => c.charCodeAt(0) & 255);
+  },
+  toISO88591(uint8array) {
+    return Array.from(Uint16Array.from(uint8array), (b) => String.fromCharCode(b)).join("");
+  },
+  fromHex(hex) {
+    const evenLengthHex = hex.length % 2 === 0 ? hex : hex.slice(0, hex.length - 1);
+    const buffer2 = [];
+    for (let i = 0; i < evenLengthHex.length; i += 2) {
+      const firstDigit = evenLengthHex[i];
+      const secondDigit = evenLengthHex[i + 1];
+      if (!HEX_DIGIT.test(firstDigit)) {
+        break;
+      }
+      if (!HEX_DIGIT.test(secondDigit)) {
+        break;
+      }
+      const hexDigit = Number.parseInt(`${firstDigit}${secondDigit}`, 16);
+      buffer2.push(hexDigit);
+    }
+    return Uint8Array.from(buffer2);
+  },
+  toHex(uint8array) {
+    return Array.from(uint8array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  },
+  toUTF8(uint8array, start, end, fatal) {
+    const basicLatin = end - start <= 20 ? tryReadBasicLatin(uint8array, start, end) : null;
+    if (basicLatin != null) {
+      return basicLatin;
+    }
+    return parseUtf8(uint8array, start, end, fatal);
+  },
+  utf8ByteLength(input) {
+    return new TextEncoder().encode(input).byteLength;
+  },
+  encodeUTF8Into(uint8array, source, byteOffset) {
+    const bytes = new TextEncoder().encode(source);
+    uint8array.set(bytes, byteOffset);
+    return bytes.byteLength;
+  },
+  randomBytes: webRandomBytes,
+  swap32(buffer2) {
+    if (buffer2.length % 4 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    }
+    for (let i = 0; i < buffer2.length; i += 4) {
+      const byte0 = buffer2[i];
+      const byte1 = buffer2[i + 1];
+      const byte2 = buffer2[i + 2];
+      const byte3 = buffer2[i + 3];
+      buffer2[i] = byte3;
+      buffer2[i + 1] = byte2;
+      buffer2[i + 2] = byte1;
+      buffer2[i + 3] = byte0;
+    }
+    return buffer2;
+  }
+};
+var hasGlobalBuffer = typeof Buffer === "function" && Buffer.prototype?._isBuffer !== true;
+var ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
+var _BSONValue = class _BSONValue {
+  get [BSON_VERSION_SYMBOL]() {
+    return BSON_MAJOR_VERSION;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](depth, options, inspect) {
+    return this.inspect(depth, options, inspect);
+  }
+};
+__name(_BSONValue, "BSONValue");
+var BSONValue = _BSONValue;
+var FLOAT = new Float64Array(1);
+var FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+FLOAT[0] = -1;
+var isBigEndian = FLOAT_BYTES[7] === 0;
+var NumberUtils = {
+  isBigEndian,
+  getNonnegativeInt32LE(source, offset) {
+    if (source[offset + 3] > 127) {
+      throw new RangeError(`Size cannot be negative at offset: ${offset}`);
+    }
+    return source[offset] | source[offset + 1] << 8 | source[offset + 2] << 16 | source[offset + 3] << 24;
+  },
+  getInt32LE(source, offset) {
+    return source[offset] | source[offset + 1] << 8 | source[offset + 2] << 16 | source[offset + 3] << 24;
+  },
+  getUint32LE(source, offset) {
+    return source[offset] + source[offset + 1] * 256 + source[offset + 2] * 65536 + source[offset + 3] * 16777216;
+  },
+  getUint32BE(source, offset) {
+    return source[offset + 3] + source[offset + 2] * 256 + source[offset + 1] * 65536 + source[offset] * 16777216;
+  },
+  getBigInt64LE(source, offset) {
+    const hi = BigInt(source[offset + 4] + source[offset + 5] * 256 + source[offset + 6] * 65536 + (source[offset + 7] << 24));
+    const lo = BigInt(source[offset] + source[offset + 1] * 256 + source[offset + 2] * 65536 + source[offset + 3] * 16777216);
+    return (hi << BigInt(32)) + lo;
+  },
+  getFloat64LE: isBigEndian ? (source, offset) => {
+    FLOAT_BYTES[7] = source[offset];
+    FLOAT_BYTES[6] = source[offset + 1];
+    FLOAT_BYTES[5] = source[offset + 2];
+    FLOAT_BYTES[4] = source[offset + 3];
+    FLOAT_BYTES[3] = source[offset + 4];
+    FLOAT_BYTES[2] = source[offset + 5];
+    FLOAT_BYTES[1] = source[offset + 6];
+    FLOAT_BYTES[0] = source[offset + 7];
+    return FLOAT[0];
+  } : (source, offset) => {
+    FLOAT_BYTES[0] = source[offset];
+    FLOAT_BYTES[1] = source[offset + 1];
+    FLOAT_BYTES[2] = source[offset + 2];
+    FLOAT_BYTES[3] = source[offset + 3];
+    FLOAT_BYTES[4] = source[offset + 4];
+    FLOAT_BYTES[5] = source[offset + 5];
+    FLOAT_BYTES[6] = source[offset + 6];
+    FLOAT_BYTES[7] = source[offset + 7];
+    return FLOAT[0];
+  },
+  setInt32BE(destination, offset, value) {
+    destination[offset + 3] = value;
+    value >>>= 8;
+    destination[offset + 2] = value;
+    value >>>= 8;
+    destination[offset + 1] = value;
+    value >>>= 8;
+    destination[offset] = value;
+    return 4;
+  },
+  setInt32LE(destination, offset, value) {
+    destination[offset] = value;
+    value >>>= 8;
+    destination[offset + 1] = value;
+    value >>>= 8;
+    destination[offset + 2] = value;
+    value >>>= 8;
+    destination[offset + 3] = value;
+    return 4;
+  },
+  setBigInt64LE(destination, offset, value) {
+    const mask32bits = BigInt(4294967295);
+    let lo = Number(value & mask32bits);
+    destination[offset] = lo;
+    lo >>= 8;
+    destination[offset + 1] = lo;
+    lo >>= 8;
+    destination[offset + 2] = lo;
+    lo >>= 8;
+    destination[offset + 3] = lo;
+    let hi = Number(value >> BigInt(32) & mask32bits);
+    destination[offset + 4] = hi;
+    hi >>= 8;
+    destination[offset + 5] = hi;
+    hi >>= 8;
+    destination[offset + 6] = hi;
+    hi >>= 8;
+    destination[offset + 7] = hi;
+    return 8;
+  },
+  setFloat64LE: isBigEndian ? (destination, offset, value) => {
+    FLOAT[0] = value;
+    destination[offset] = FLOAT_BYTES[7];
+    destination[offset + 1] = FLOAT_BYTES[6];
+    destination[offset + 2] = FLOAT_BYTES[5];
+    destination[offset + 3] = FLOAT_BYTES[4];
+    destination[offset + 4] = FLOAT_BYTES[3];
+    destination[offset + 5] = FLOAT_BYTES[2];
+    destination[offset + 6] = FLOAT_BYTES[1];
+    destination[offset + 7] = FLOAT_BYTES[0];
+    return 8;
+  } : (destination, offset, value) => {
+    FLOAT[0] = value;
+    destination[offset] = FLOAT_BYTES[0];
+    destination[offset + 1] = FLOAT_BYTES[1];
+    destination[offset + 2] = FLOAT_BYTES[2];
+    destination[offset + 3] = FLOAT_BYTES[3];
+    destination[offset + 4] = FLOAT_BYTES[4];
+    destination[offset + 5] = FLOAT_BYTES[5];
+    destination[offset + 6] = FLOAT_BYTES[6];
+    destination[offset + 7] = FLOAT_BYTES[7];
+    return 8;
+  }
+};
+var _Binary = class _Binary extends BSONValue {
+  get _bsontype() {
+    return "Binary";
+  }
+  constructor(buffer2, subType) {
+    super();
+    if (!(buffer2 == null) && typeof buffer2 === "string" && !ArrayBuffer.isView(buffer2) && !isAnyArrayBuffer(buffer2) && !Array.isArray(buffer2)) {
+      throw new BSONError("Binary can only be constructed from Uint8Array or number[]");
+    }
+    this.sub_type = subType ?? _Binary.BSON_BINARY_SUBTYPE_DEFAULT;
+    if (buffer2 == null) {
+      this.buffer = ByteUtils.allocate(_Binary.BUFFER_SIZE);
+      this.position = 0;
+    } else {
+      this.buffer = Array.isArray(buffer2) ? ByteUtils.fromNumberArray(buffer2) : ByteUtils.toLocalBufferType(buffer2);
+      this.position = this.buffer.byteLength;
+    }
+  }
+  put(byteValue) {
+    if (typeof byteValue === "string" && byteValue.length !== 1) {
+      throw new BSONError("only accepts single character String");
+    } else if (typeof byteValue !== "number" && byteValue.length !== 1)
+      throw new BSONError("only accepts single character Uint8Array or Array");
+    let decodedByte;
+    if (typeof byteValue === "string") {
+      decodedByte = byteValue.charCodeAt(0);
+    } else if (typeof byteValue === "number") {
+      decodedByte = byteValue;
+    } else {
+      decodedByte = byteValue[0];
+    }
+    if (decodedByte < 0 || decodedByte > 255) {
+      throw new BSONError("only accepts number in a valid unsigned byte range 0-255");
+    }
+    if (this.buffer.byteLength > this.position) {
+      this.buffer[this.position++] = decodedByte;
+    } else {
+      const newSpace = ByteUtils.allocate(_Binary.BUFFER_SIZE + this.buffer.length);
+      newSpace.set(this.buffer, 0);
+      this.buffer = newSpace;
+      this.buffer[this.position++] = decodedByte;
+    }
+  }
+  write(sequence, offset) {
+    offset = typeof offset === "number" ? offset : this.position;
+    if (this.buffer.byteLength < offset + sequence.length) {
+      const newSpace = ByteUtils.allocate(this.buffer.byteLength + sequence.length);
+      newSpace.set(this.buffer, 0);
+      this.buffer = newSpace;
+    }
+    if (ArrayBuffer.isView(sequence)) {
+      this.buffer.set(ByteUtils.toLocalBufferType(sequence), offset);
+      this.position = offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;
+    } else if (typeof sequence === "string") {
+      throw new BSONError("input cannot be string");
+    }
+  }
+  read(position, length) {
+    length = length && length > 0 ? length : this.position;
+    const end = position + length;
+    return this.buffer.subarray(position, end > this.position ? this.position : end);
+  }
+  value() {
+    return this.buffer.length === this.position ? this.buffer : this.buffer.subarray(0, this.position);
+  }
+  length() {
+    return this.position;
+  }
+  toJSON() {
+    return ByteUtils.toBase64(this.buffer.subarray(0, this.position));
+  }
+  toString(encoding) {
+    if (encoding === "hex")
+      return ByteUtils.toHex(this.buffer.subarray(0, this.position));
+    if (encoding === "base64")
+      return ByteUtils.toBase64(this.buffer.subarray(0, this.position));
+    if (encoding === "utf8" || encoding === "utf-8")
+      return ByteUtils.toUTF8(this.buffer, 0, this.position, false);
+    return ByteUtils.toUTF8(this.buffer, 0, this.position, false);
+  }
+  toExtendedJSON(options) {
+    options = options || {};
+    if (this.sub_type === _Binary.SUBTYPE_VECTOR) {
+      validateBinaryVector(this);
+    }
+    const base64String = ByteUtils.toBase64(this.buffer);
+    const subType = Number(this.sub_type).toString(16);
+    if (options.legacy) {
+      return {
+        $binary: base64String,
+        $type: subType.length === 1 ? "0" + subType : subType
+      };
+    }
+    return {
+      $binary: {
+        base64: base64String,
+        subType: subType.length === 1 ? "0" + subType : subType
+      }
+    };
+  }
+  toUUID() {
+    if (this.sub_type === _Binary.SUBTYPE_UUID) {
+      return new UUID(this.buffer.subarray(0, this.position));
+    }
+    throw new BSONError(`Binary sub_type "${this.sub_type}" is not supported for converting to UUID. Only "${_Binary.SUBTYPE_UUID}" is currently supported.`);
+  }
+  static createFromHexString(hex, subType) {
+    return new _Binary(ByteUtils.fromHex(hex), subType);
+  }
+  static createFromBase64(base64, subType) {
+    return new _Binary(ByteUtils.fromBase64(base64), subType);
+  }
+  static fromExtendedJSON(doc, options) {
+    options = options || {};
+    let data;
+    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 = ByteUtils.fromBase64(doc.$binary);
+      } else {
+        if (typeof doc.$binary !== "string") {
+          type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0;
+          data = ByteUtils.fromBase64(doc.$binary.base64);
+        }
+      }
+    } else if ("$uuid" in doc) {
+      type = 4;
+      data = UUID.bytesFromString(doc.$uuid);
+    }
+    if (!data) {
+      throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
+    }
+    return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new _Binary(data, type);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    const base64 = ByteUtils.toBase64(this.buffer.subarray(0, this.position));
+    const base64Arg = inspect(base64, options);
+    const subTypeArg = inspect(this.sub_type, options);
+    return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`;
+  }
+  toInt8Array() {
+    if (this.sub_type !== _Binary.SUBTYPE_VECTOR) {
+      throw new BSONError("Binary sub_type is not Vector");
+    }
+    if (this.buffer[0] !== _Binary.VECTOR_TYPE.Int8) {
+      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));
+  }
+  toFloat32Array() {
+    if (this.sub_type !== _Binary.SUBTYPE_VECTOR) {
+      throw new BSONError("Binary sub_type is not Vector");
+    }
+    if (this.buffer[0] !== _Binary.VECTOR_TYPE.Float32) {
+      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));
+    if (NumberUtils.isBigEndian)
+      ByteUtils.swap32(floatBytes);
+    return new Float32Array(floatBytes.buffer);
+  }
+  toPackedBits() {
+    if (this.sub_type !== _Binary.SUBTYPE_VECTOR) {
+      throw new BSONError("Binary sub_type is not Vector");
+    }
+    if (this.buffer[0] !== _Binary.VECTOR_TYPE.PackedBit) {
+      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));
+  }
+  toBits() {
+    if (this.sub_type !== _Binary.SUBTYPE_VECTOR) {
+      throw new BSONError("Binary sub_type is not Vector");
+    }
+    if (this.buffer[0] !== _Binary.VECTOR_TYPE.PackedBit) {
+      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);
+    for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) {
+      const byteOffset = bitOffset / 8 | 0;
+      const byte = this.buffer[byteOffset + 2];
+      const shift = 7 - bitOffset % 8;
+      const bit = byte >> shift & 1;
+      bits[bitOffset] = bit;
+    }
+    return bits;
+  }
+  static fromInt8Array(array) {
+    const buffer2 = ByteUtils.allocate(array.byteLength + 2);
+    buffer2[0] = _Binary.VECTOR_TYPE.Int8;
+    buffer2[1] = 0;
+    const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    buffer2.set(intBytes, 2);
+    const bin = new this(buffer2, this.SUBTYPE_VECTOR);
+    validateBinaryVector(bin);
+    return bin;
+  }
+  static fromFloat32Array(array) {
+    const binaryBytes = ByteUtils.allocate(array.byteLength + 2);
+    binaryBytes[0] = _Binary.VECTOR_TYPE.Float32;
+    binaryBytes[1] = 0;
+    const floatBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    binaryBytes.set(floatBytes, 2);
+    if (NumberUtils.isBigEndian)
+      ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2));
+    const bin = new this(binaryBytes, this.SUBTYPE_VECTOR);
+    validateBinaryVector(bin);
+    return bin;
+  }
+  static fromPackedBits(array, padding = 0) {
+    const buffer2 = ByteUtils.allocate(array.byteLength + 2);
+    buffer2[0] = _Binary.VECTOR_TYPE.PackedBit;
+    buffer2[1] = padding;
+    buffer2.set(array, 2);
+    const bin = new this(buffer2, this.SUBTYPE_VECTOR);
+    validateBinaryVector(bin);
+    return bin;
+  }
+  static fromBits(bits) {
+    const byteLength = bits.length + 7 >>> 3;
+    const bytes = new Uint8Array(byteLength + 2);
+    bytes[0] = _Binary.VECTOR_TYPE.PackedBit;
+    const remainder = bits.length % 8;
+    bytes[1] = remainder === 0 ? 0 : 8 - remainder;
+    for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) {
+      const byteOffset = bitOffset >>> 3;
+      const bit = bits[bitOffset];
+      if (bit !== 0 && bit !== 1) {
+        throw new BSONError(`Invalid bit value at ${bitOffset}: must be 0 or 1, found ${bits[bitOffset]}`);
+      }
+      if (bit === 0)
+        continue;
+      const shift = 7 - bitOffset % 8;
+      bytes[byteOffset + 2] |= bit << shift;
+    }
+    return new this(bytes, _Binary.SUBTYPE_VECTOR);
+  }
+};
+__name(_Binary, "Binary");
+var Binary = _Binary;
+Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
+Binary.BUFFER_SIZE = 256;
+Binary.SUBTYPE_DEFAULT = 0;
+Binary.SUBTYPE_FUNCTION = 1;
+Binary.SUBTYPE_BYTE_ARRAY = 2;
+Binary.SUBTYPE_UUID_OLD = 3;
+Binary.SUBTYPE_UUID = 4;
+Binary.SUBTYPE_MD5 = 5;
+Binary.SUBTYPE_ENCRYPTED = 6;
+Binary.SUBTYPE_COLUMN = 7;
+Binary.SUBTYPE_SENSITIVE = 8;
+Binary.SUBTYPE_VECTOR = 9;
+Binary.SUBTYPE_USER_DEFINED = 128;
+Binary.VECTOR_TYPE = Object.freeze({
+  Int8: 3,
+  Float32: 39,
+  PackedBit: 16
+});
+function validateBinaryVector(vector) {
+  if (vector.sub_type !== Binary.SUBTYPE_VECTOR)
+    return;
+  const size = vector.position;
+  const datatype = vector.buffer[0];
+  const padding = vector.buffer[1];
+  if ((datatype === Binary.VECTOR_TYPE.Float32 || datatype === Binary.VECTOR_TYPE.Int8) && padding !== 0) {
+    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");
+  }
+  if (datatype === Binary.VECTOR_TYPE.PackedBit && padding > 7) {
+    throw new BSONError(`Invalid Vector: padding must be a value between 0 and 7. found: ${padding}`);
+  }
+}
+__name(validateBinaryVector, "validateBinaryVector");
+var UUID_BYTE_LENGTH = 16;
+var UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
+var UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
+var _UUID = class _UUID extends Binary {
+  constructor(input) {
+    let bytes;
+    if (input == null) {
+      bytes = _UUID.generate();
+    } else if (input instanceof _UUID) {
+      bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));
+    } else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
+      bytes = ByteUtils.toLocalBufferType(input);
+    } else if (typeof input === "string") {
+      bytes = _UUID.bytesFromString(input);
+    } else {
+      throw new BSONError("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);
+  }
+  get id() {
+    return this.buffer;
+  }
+  set id(value) {
+    this.buffer = value;
+  }
+  toHexString(includeDashes = true) {
+    if (includeDashes) {
+      return [
+        ByteUtils.toHex(this.buffer.subarray(0, 4)),
+        ByteUtils.toHex(this.buffer.subarray(4, 6)),
+        ByteUtils.toHex(this.buffer.subarray(6, 8)),
+        ByteUtils.toHex(this.buffer.subarray(8, 10)),
+        ByteUtils.toHex(this.buffer.subarray(10, 16))
+      ].join("-");
+    }
+    return ByteUtils.toHex(this.buffer);
+  }
+  toString(encoding) {
+    if (encoding === "hex")
+      return ByteUtils.toHex(this.id);
+    if (encoding === "base64")
+      return ByteUtils.toBase64(this.id);
+    return this.toHexString();
+  }
+  toJSON() {
+    return this.toHexString();
+  }
+  equals(otherId) {
+    if (!otherId) {
+      return false;
+    }
+    if (otherId instanceof _UUID) {
+      return ByteUtils.equals(otherId.id, this.id);
+    }
+    try {
+      return ByteUtils.equals(new _UUID(otherId).id, this.id);
+    } catch {
+      return false;
+    }
+  }
+  toBinary() {
+    return new Binary(this.id, Binary.SUBTYPE_UUID);
+  }
+  static generate() {
+    const bytes = ByteUtils.randomBytes(UUID_BYTE_LENGTH);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    return bytes;
+  }
+  static isValid(input) {
+    if (!input) {
+      return false;
+    }
+    if (typeof input === "string") {
+      return _UUID.isValidUUIDString(input);
+    }
+    if (isUint8Array(input)) {
+      return input.byteLength === UUID_BYTE_LENGTH;
+    }
+    return input._bsontype === "Binary" && input.sub_type === this.SUBTYPE_UUID && input.buffer.byteLength === 16;
+  }
+  static createFromHexString(hexString) {
+    const buffer2 = _UUID.bytesFromString(hexString);
+    return new _UUID(buffer2);
+  }
+  static createFromBase64(base64) {
+    return new _UUID(ByteUtils.fromBase64(base64));
+  }
+  static bytesFromString(representation) {
+    if (!_UUID.isValidUUIDString(representation)) {
+      throw new BSONError("UUID string representation must be 32 hex digits or canonical hyphenated representation");
+    }
+    return ByteUtils.fromHex(representation.replace(/-/g, ""));
+  }
+  static isValidUUIDString(representation) {
+    return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    return `new UUID(${inspect(this.toHexString(), options)})`;
+  }
+};
+__name(_UUID, "UUID");
+var UUID = _UUID;
+var _Code = class _Code extends BSONValue {
+  get _bsontype() {
+    return "Code";
+  }
+  constructor(code, scope) {
+    super();
+    this.code = code.toString();
+    this.scope = scope ?? null;
+  }
+  toJSON() {
+    if (this.scope != null) {
+      return { code: this.code, scope: this.scope };
+    }
+    return { code: this.code };
+  }
+  toExtendedJSON() {
+    if (this.scope) {
+      return { $code: this.code, $scope: this.scope };
+    }
+    return { $code: this.code };
+  }
+  static fromExtendedJSON(doc) {
+    return new _Code(doc.$code, doc.$scope);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    let parametersString = inspect(this.code, options);
+    const multiLineFn = parametersString.includes("\n");
+    if (this.scope != null) {
+      parametersString += `,${multiLineFn ? "\n" : " "}${inspect(this.scope, options)}`;
+    }
+    const endingNewline = multiLineFn && this.scope === null;
+    return `new Code(${multiLineFn ? "\n" : ""}${parametersString}${endingNewline ? "\n" : ""})`;
+  }
+};
+__name(_Code, "Code");
+var Code = _Code;
+function isDBRefLike(value) {
+  return value != null && typeof value === "object" && "$id" in value && value.$id != null && "$ref" in value && typeof value.$ref === "string" && (!("$db" in value) || "$db" in value && typeof value.$db === "string");
+}
+__name(isDBRefLike, "isDBRefLike");
+var _DBRef = class _DBRef extends BSONValue {
+  get _bsontype() {
+    return "DBRef";
+  }
+  constructor(collection, oid, db, fields) {
+    super();
+    const parts = collection.split(".");
+    if (parts.length === 2) {
+      db = parts.shift();
+      collection = parts.shift();
+    }
+    this.collection = collection;
+    this.oid = oid;
+    this.db = db;
+    this.fields = fields || {};
+  }
+  get namespace() {
+    return this.collection;
+  }
+  set namespace(value) {
+    this.collection = value;
+  }
+  toJSON() {
+    const o = Object.assign({
+      $ref: this.collection,
+      $id: this.oid
+    }, this.fields);
+    if (this.db != null)
+      o.$db = this.db;
+    return o;
+  }
+  toExtendedJSON(options) {
+    options = options || {};
+    let o = {
+      $ref: this.collection,
+      $id: this.oid
+    };
+    if (options.legacy) {
+      return o;
+    }
+    if (this.db)
+      o.$db = this.db;
+    o = Object.assign(o, this.fields);
+    return o;
+  }
+  static fromExtendedJSON(doc) {
+    const copy = Object.assign({}, doc);
+    delete copy.$ref;
+    delete copy.$id;
+    delete copy.$db;
+    return new _DBRef(doc.$ref, doc.$id, doc.$db, copy);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    const args = [
+      inspect(this.namespace, options),
+      inspect(this.oid, options),
+      ...this.db ? [inspect(this.db, options)] : [],
+      ...Object.keys(this.fields).length > 0 ? [inspect(this.fields, options)] : []
+    ];
+    args[1] = inspect === defaultInspect ? `new ObjectId(${args[1]})` : args[1];
+    return `new DBRef(${args.join(", ")})`;
+  }
+};
+__name(_DBRef, "DBRef");
+var DBRef = _DBRef;
+function removeLeadingZerosAndExplicitPlus(str) {
+  if (str === "") {
+    return str;
+  }
+  let startIndex = 0;
+  const isNegative = str[startIndex] === "-";
+  const isExplicitlyPositive = str[startIndex] === "+";
+  if (isExplicitlyPositive || isNegative) {
+    startIndex += 1;
+  }
+  let foundInsignificantZero = false;
+  for (; startIndex < str.length && str[startIndex] === "0"; ++startIndex) {
+    foundInsignificantZero = true;
+  }
+  if (!foundInsignificantZero) {
+    return isExplicitlyPositive ? str.slice(1) : str;
+  }
+  return `${isNegative ? "-" : ""}${str.length === startIndex ? "0" : str.slice(startIndex)}`;
+}
+__name(removeLeadingZerosAndExplicitPlus, "removeLeadingZerosAndExplicitPlus");
+function validateStringCharacters(str, radix) {
+  radix = radix ?? 10;
+  const validCharacters = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, radix);
+  const regex = new RegExp(`[^-+${validCharacters}]`, "i");
+  return regex.test(str) ? false : str;
+}
+__name(validateStringCharacters, "validateStringCharacters");
+var wasm = void 0;
+try {
+  wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11])), {}).exports;
+} catch {
+}
+var TWO_PWR_16_DBL = 1 << 16;
+var TWO_PWR_24_DBL = 1 << 24;
+var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
+var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
+var INT_CACHE = {};
+var UINT_CACHE = {};
+var MAX_INT64_STRING_LENGTH = 20;
+var DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/;
+var _Long = class _Long extends BSONValue {
+  get _bsontype() {
+    return "Long";
+  }
+  get __isLong__() {
+    return true;
+  }
+  constructor(lowOrValue = 0, highOrUnsigned, unsigned) {
+    super();
+    const unsignedBool = typeof highOrUnsigned === "boolean" ? highOrUnsigned : Boolean(unsigned);
+    const high = typeof highOrUnsigned === "number" ? highOrUnsigned : 0;
+    const res = typeof lowOrValue === "string" ? _Long.fromString(lowOrValue, unsignedBool) : typeof lowOrValue === "bigint" ? _Long.fromBigInt(lowOrValue, unsignedBool) : { low: lowOrValue | 0, high: high | 0, unsigned: unsignedBool };
+    this.low = res.low;
+    this.high = res.high;
+    this.unsigned = res.unsigned;
+  }
+  static fromBits(lowBits, highBits, unsigned) {
+    return new _Long(lowBits, highBits, unsigned);
+  }
+  static fromInt(value, unsigned) {
+    let obj, cachedObj, cache;
+    if (unsigned) {
+      value >>>= 0;
+      if (cache = 0 <= value && value < 256) {
+        cachedObj = UINT_CACHE[value];
+        if (cachedObj)
+          return cachedObj;
+      }
+      obj = _Long.fromBits(value, (value | 0) < 0 ? -1 : 0, true);
+      if (cache)
+        UINT_CACHE[value] = obj;
+      return obj;
+    } else {
+      value |= 0;
+      if (cache = -128 <= value && value < 128) {
+        cachedObj = INT_CACHE[value];
+        if (cachedObj)
+          return cachedObj;
+      }
+      obj = _Long.fromBits(value, value < 0 ? -1 : 0, false);
+      if (cache)
+        INT_CACHE[value] = obj;
+      return obj;
+    }
+  }
+  static fromNumber(value, unsigned) {
+    if (isNaN(value))
+      return unsigned ? _Long.UZERO : _Long.ZERO;
+    if (unsigned) {
+      if (value < 0)
+        return _Long.UZERO;
+      if (value >= TWO_PWR_64_DBL)
+        return _Long.MAX_UNSIGNED_VALUE;
+    } else {
+      if (value <= -9223372036854776e3)
+        return _Long.MIN_VALUE;
+      if (value + 1 >= TWO_PWR_63_DBL)
+        return _Long.MAX_VALUE;
+    }
+    if (value < 0)
+      return _Long.fromNumber(-value, unsigned).neg();
+    return _Long.fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
+  }
+  static fromBigInt(value, unsigned) {
+    const FROM_BIGINT_BIT_MASK = BigInt(4294967295);
+    const FROM_BIGINT_BIT_SHIFT = BigInt(32);
+    return new _Long(Number(value & FROM_BIGINT_BIT_MASK), Number(value >> FROM_BIGINT_BIT_SHIFT & FROM_BIGINT_BIT_MASK), unsigned);
+  }
+  static _fromString(str, unsigned, radix) {
+    if (str.length === 0)
+      throw new BSONError("empty string");
+    if (radix < 2 || 36 < radix)
+      throw new BSONError("radix");
+    let p;
+    if ((p = str.indexOf("-")) > 0)
+      throw new BSONError("interior hyphen");
+    else if (p === 0) {
+      return _Long._fromString(str.substring(1), unsigned, radix).neg();
+    }
+    const radixToPower = _Long.fromNumber(Math.pow(radix, 8));
+    let result = _Long.ZERO;
+    for (let i = 0; i < str.length; i += 8) {
+      const size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
+      if (size < 8) {
+        const power = _Long.fromNumber(Math.pow(radix, size));
+        result = result.mul(power).add(_Long.fromNumber(value));
+      } else {
+        result = result.mul(radixToPower);
+        result = result.add(_Long.fromNumber(value));
+      }
+    }
+    result.unsigned = unsigned;
+    return result;
+  }
+  static fromStringStrict(str, unsignedOrRadix, radix) {
+    let unsigned = false;
+    if (typeof unsignedOrRadix === "number") {
+      radix = unsignedOrRadix, unsignedOrRadix = false;
+    } else {
+      unsigned = !!unsignedOrRadix;
+    }
+    radix ?? (radix = 10);
+    if (str.trim() !== str) {
+      throw new BSONError(`Input: '${str}' contains leading and/or trailing whitespace`);
+    }
+    if (!validateStringCharacters(str, radix)) {
+      throw new BSONError(`Input: '${str}' contains invalid characters for radix: ${radix}`);
+    }
+    const cleanedStr = removeLeadingZerosAndExplicitPlus(str);
+    const result = _Long._fromString(cleanedStr, unsigned, radix);
+    if (result.toString(radix).toLowerCase() !== cleanedStr.toLowerCase()) {
+      throw new BSONError(`Input: ${str} is not representable as ${result.unsigned ? "an unsigned" : "a signed"} 64-bit Long ${radix != null ? `with radix: ${radix}` : ""}`);
+    }
+    return result;
+  }
+  static fromString(str, unsignedOrRadix, radix) {
+    let unsigned = false;
+    if (typeof unsignedOrRadix === "number") {
+      radix = unsignedOrRadix, unsignedOrRadix = false;
+    } else {
+      unsigned = !!unsignedOrRadix;
+    }
+    radix ?? (radix = 10);
+    if (str === "NaN" && radix < 24) {
+      return _Long.ZERO;
+    } else if ((str === "Infinity" || str === "+Infinity" || str === "-Infinity") && radix < 35) {
+      return _Long.ZERO;
+    }
+    return _Long._fromString(str, unsigned, radix);
+  }
+  static fromBytes(bytes, unsigned, le) {
+    return le ? _Long.fromBytesLE(bytes, unsigned) : _Long.fromBytesBE(bytes, unsigned);
+  }
+  static fromBytesLE(bytes, unsigned) {
+    return new _Long(bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, unsigned);
+  }
+  static fromBytesBE(bytes, unsigned) {
+    return new _Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned);
+  }
+  static isLong(value) {
+    return value != null && typeof value === "object" && "__isLong__" in value && value.__isLong__ === true;
+  }
+  static fromValue(val, unsigned) {
+    if (typeof val === "number")
+      return _Long.fromNumber(val, unsigned);
+    if (typeof val === "string")
+      return _Long.fromString(val, unsigned);
+    return _Long.fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
+  }
+  add(addend) {
+    if (!_Long.isLong(addend))
+      addend = _Long.fromValue(addend);
+    const a48 = this.high >>> 16;
+    const a32 = this.high & 65535;
+    const a16 = this.low >>> 16;
+    const a00 = this.low & 65535;
+    const b48 = addend.high >>> 16;
+    const b32 = addend.high & 65535;
+    const b16 = addend.low >>> 16;
+    const b00 = addend.low & 65535;
+    let c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+    c00 += a00 + b00;
+    c16 += c00 >>> 16;
+    c00 &= 65535;
+    c16 += a16 + b16;
+    c32 += c16 >>> 16;
+    c16 &= 65535;
+    c32 += a32 + b32;
+    c48 += c32 >>> 16;
+    c32 &= 65535;
+    c48 += a48 + b48;
+    c48 &= 65535;
+    return _Long.fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+  }
+  and(other) {
+    if (!_Long.isLong(other))
+      other = _Long.fromValue(other);
+    return _Long.fromBits(this.low & other.low, this.high & other.high, this.unsigned);
+  }
+  compare(other) {
+    if (!_Long.isLong(other))
+      other = _Long.fromValue(other);
+    if (this.eq(other))
+      return 0;
+    const thisNeg = this.isNegative(), otherNeg = other.isNegative();
+    if (thisNeg && !otherNeg)
+      return -1;
+    if (!thisNeg && otherNeg)
+      return 1;
+    if (!this.unsigned)
+      return this.sub(other).isNegative() ? -1 : 1;
+    return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
+  }
+  comp(other) {
+    return this.compare(other);
+  }
+  divide(divisor) {
+    if (!_Long.isLong(divisor))
+      divisor = _Long.fromValue(divisor);
+    if (divisor.isZero())
+      throw new BSONError("division by zero");
+    if (wasm) {
+      if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
+        return this;
+      }
+      const low = (this.unsigned ? wasm.div_u : wasm.div_s)(this.low, this.high, divisor.low, divisor.high);
+      return _Long.fromBits(low, wasm.get_high(), this.unsigned);
+    }
+    if (this.isZero())
+      return this.unsigned ? _Long.UZERO : _Long.ZERO;
+    let approx, rem, res;
+    if (!this.unsigned) {
+      if (this.eq(_Long.MIN_VALUE)) {
+        if (divisor.eq(_Long.ONE) || divisor.eq(_Long.NEG_ONE))
+          return _Long.MIN_VALUE;
+        else if (divisor.eq(_Long.MIN_VALUE))
+          return _Long.ONE;
+        else {
+          const halfThis = this.shr(1);
+          approx = halfThis.div(divisor).shl(1);
+          if (approx.eq(_Long.ZERO)) {
+            return divisor.isNegative() ? _Long.ONE : _Long.NEG_ONE;
+          } else {
+            rem = this.sub(divisor.mul(approx));
+            res = approx.add(rem.div(divisor));
+            return res;
+          }
+        }
+      } else if (divisor.eq(_Long.MIN_VALUE))
+        return this.unsigned ? _Long.UZERO : _Long.ZERO;
+      if (this.isNegative()) {
+        if (divisor.isNegative())
+          return this.neg().div(divisor.neg());
+        return this.neg().div(divisor).neg();
+      } else if (divisor.isNegative())
+        return this.div(divisor.neg()).neg();
+      res = _Long.ZERO;
+    } else {
+      if (!divisor.unsigned)
+        divisor = divisor.toUnsigned();
+      if (divisor.gt(this))
+        return _Long.UZERO;
+      if (divisor.gt(this.shru(1)))
+        return _Long.UONE;
+      res = _Long.UZERO;
+    }
+    rem = this;
+    while (rem.gte(divisor)) {
+      approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
+      const log2 = Math.ceil(Math.log(approx) / Math.LN2);
+      const delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
+      let approxRes = _Long.fromNumber(approx);
+      let approxRem = approxRes.mul(divisor);
+      while (approxRem.isNegative() || approxRem.gt(rem)) {
+        approx -= delta;
+        approxRes = _Long.fromNumber(approx, this.unsigned);
+        approxRem = approxRes.mul(divisor);
+      }
+      if (approxRes.isZero())
+        approxRes = _Long.ONE;
+      res = res.add(approxRes);
+      rem = rem.sub(approxRem);
+    }
+    return res;
+  }
+  div(divisor) {
+    return this.divide(divisor);
+  }
+  equals(other) {
+    if (!_Long.isLong(other))
+      other = _Long.fromValue(other);
+    if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
+      return false;
+    return this.high === other.high && this.low === other.low;
+  }
+  eq(other) {
+    return this.equals(other);
+  }
+  getHighBits() {
+    return this.high;
+  }
+  getHighBitsUnsigned() {
+    return this.high >>> 0;
+  }
+  getLowBits() {
+    return this.low;
+  }
+  getLowBitsUnsigned() {
+    return this.low >>> 0;
+  }
+  getNumBitsAbs() {
+    if (this.isNegative()) {
+      return this.eq(_Long.MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
+    }
+    const val = this.high !== 0 ? this.high : this.low;
+    let bit;
+    for (bit = 31; bit > 0; bit--)
+      if ((val & 1 << bit) !== 0)
+        break;
+    return this.high !== 0 ? bit + 33 : bit + 1;
+  }
+  greaterThan(other) {
+    return this.comp(other) > 0;
+  }
+  gt(other) {
+    return this.greaterThan(other);
+  }
+  greaterThanOrEqual(other) {
+    return this.comp(other) >= 0;
+  }
+  gte(other) {
+    return this.greaterThanOrEqual(other);
+  }
+  ge(other) {
+    return this.greaterThanOrEqual(other);
+  }
+  isEven() {
+    return (this.low & 1) === 0;
+  }
+  isNegative() {
+    return !this.unsigned && this.high < 0;
+  }
+  isOdd() {
+    return (this.low & 1) === 1;
+  }
+  isPositive() {
+    return this.unsigned || this.high >= 0;
+  }
+  isZero() {
+    return this.high === 0 && this.low === 0;
+  }
+  lessThan(other) {
+    return this.comp(other) < 0;
+  }
+  lt(other) {
+    return this.lessThan(other);
+  }
+  lessThanOrEqual(other) {
+    return this.comp(other) <= 0;
+  }
+  lte(other) {
+    return this.lessThanOrEqual(other);
+  }
+  modulo(divisor) {
+    if (!_Long.isLong(divisor))
+      divisor = _Long.fromValue(divisor);
+    if (wasm) {
+      const low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(this.low, this.high, divisor.low, divisor.high);
+      return _Long.fromBits(low, wasm.get_high(), this.unsigned);
+    }
+    return this.sub(this.div(divisor).mul(divisor));
+  }
+  mod(divisor) {
+    return this.modulo(divisor);
+  }
+  rem(divisor) {
+    return this.modulo(divisor);
+  }
+  multiply(multiplier) {
+    if (this.isZero())
+      return _Long.ZERO;
+    if (!_Long.isLong(multiplier))
+      multiplier = _Long.fromValue(multiplier);
+    if (wasm) {
+      const low = wasm.mul(this.low, this.high, multiplier.low, multiplier.high);
+      return _Long.fromBits(low, wasm.get_high(), this.unsigned);
+    }
+    if (multiplier.isZero())
+      return _Long.ZERO;
+    if (this.eq(_Long.MIN_VALUE))
+      return multiplier.isOdd() ? _Long.MIN_VALUE : _Long.ZERO;
+    if (multiplier.eq(_Long.MIN_VALUE))
+      return this.isOdd() ? _Long.MIN_VALUE : _Long.ZERO;
+    if (this.isNegative()) {
+      if (multiplier.isNegative())
+        return this.neg().mul(multiplier.neg());
+      else
+        return this.neg().mul(multiplier).neg();
+    } else if (multiplier.isNegative())
+      return this.mul(multiplier.neg()).neg();
+    if (this.lt(_Long.TWO_PWR_24) && multiplier.lt(_Long.TWO_PWR_24))
+      return _Long.fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
+    const a48 = this.high >>> 16;
+    const a32 = this.high & 65535;
+    const a16 = this.low >>> 16;
+    const a00 = this.low & 65535;
+    const b48 = multiplier.high >>> 16;
+    const b32 = multiplier.high & 65535;
+    const b16 = multiplier.low >>> 16;
+    const b00 = multiplier.low & 65535;
+    let c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+    c00 += a00 * b00;
+    c16 += c00 >>> 16;
+    c00 &= 65535;
+    c16 += a16 * b00;
+    c32 += c16 >>> 16;
+    c16 &= 65535;
+    c16 += a00 * b16;
+    c32 += c16 >>> 16;
+    c16 &= 65535;
+    c32 += a32 * b00;
+    c48 += c32 >>> 16;
+    c32 &= 65535;
+    c32 += a16 * b16;
+    c48 += c32 >>> 16;
+    c32 &= 65535;
+    c32 += a00 * b32;
+    c48 += c32 >>> 16;
+    c32 &= 65535;
+    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+    c48 &= 65535;
+    return _Long.fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+  }
+  mul(multiplier) {
+    return this.multiply(multiplier);
+  }
+  negate() {
+    if (!this.unsigned && this.eq(_Long.MIN_VALUE))
+      return _Long.MIN_VALUE;
+    return this.not().add(_Long.ONE);
+  }
+  neg() {
+    return this.negate();
+  }
+  not() {
+    return _Long.fromBits(~this.low, ~this.high, this.unsigned);
+  }
+  notEquals(other) {
+    return !this.equals(other);
+  }
+  neq(other) {
+    return this.notEquals(other);
+  }
+  ne(other) {
+    return this.notEquals(other);
+  }
+  or(other) {
+    if (!_Long.isLong(other))
+      other = _Long.fromValue(other);
+    return _Long.fromBits(this.low | other.low, this.high | other.high, this.unsigned);
+  }
+  shiftLeft(numBits) {
+    if (_Long.isLong(numBits))
+      numBits = numBits.toInt();
+    if ((numBits &= 63) === 0)
+      return this;
+    else if (numBits < 32)
+      return _Long.fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
+    else
+      return _Long.fromBits(0, this.low << numBits - 32, this.unsigned);
+  }
+  shl(numBits) {
+    return this.shiftLeft(numBits);
+  }
+  shiftRight(numBits) {
+    if (_Long.isLong(numBits))
+      numBits = numBits.toInt();
+    if ((numBits &= 63) === 0)
+      return this;
+    else if (numBits < 32)
+      return _Long.fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
+    else
+      return _Long.fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+  }
+  shr(numBits) {
+    return this.shiftRight(numBits);
+  }
+  shiftRightUnsigned(numBits) {
+    if (_Long.isLong(numBits))
+      numBits = numBits.toInt();
+    numBits &= 63;
+    if (numBits === 0)
+      return this;
+    else {
+      const high = this.high;
+      if (numBits < 32) {
+        const low = this.low;
+        return _Long.fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits, this.unsigned);
+      } else if (numBits === 32)
+        return _Long.fromBits(high, 0, this.unsigned);
+      else
+        return _Long.fromBits(high >>> numBits - 32, 0, this.unsigned);
+    }
+  }
+  shr_u(numBits) {
+    return this.shiftRightUnsigned(numBits);
+  }
+  shru(numBits) {
+    return this.shiftRightUnsigned(numBits);
+  }
+  subtract(subtrahend) {
+    if (!_Long.isLong(subtrahend))
+      subtrahend = _Long.fromValue(subtrahend);
+    return this.add(subtrahend.neg());
+  }
+  sub(subtrahend) {
+    return this.subtract(subtrahend);
+  }
+  toInt() {
+    return this.unsigned ? this.low >>> 0 : this.low;
+  }
+  toNumber() {
+    if (this.unsigned)
+      return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
+    return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
+  }
+  toBigInt() {
+    return BigInt(this.toString());
+  }
+  toBytes(le) {
+    return le ? this.toBytesLE() : this.toBytesBE();
+  }
+  toBytesLE() {
+    const hi = this.high, lo = this.low;
+    return [
+      lo & 255,
+      lo >>> 8 & 255,
+      lo >>> 16 & 255,
+      lo >>> 24,
+      hi & 255,
+      hi >>> 8 & 255,
+      hi >>> 16 & 255,
+      hi >>> 24
+    ];
+  }
+  toBytesBE() {
+    const hi = this.high, lo = this.low;
+    return [
+      hi >>> 24,
+      hi >>> 16 & 255,
+      hi >>> 8 & 255,
+      hi & 255,
+      lo >>> 24,
+      lo >>> 16 & 255,
+      lo >>> 8 & 255,
+      lo & 255
+    ];
+  }
+  toSigned() {
+    if (!this.unsigned)
+      return this;
+    return _Long.fromBits(this.low, this.high, false);
+  }
+  toString(radix) {
+    radix = radix || 10;
+    if (radix < 2 || 36 < radix)
+      throw new BSONError("radix");
+    if (this.isZero())
+      return "0";
+    if (this.isNegative()) {
+      if (this.eq(_Long.MIN_VALUE)) {
+        const radixLong = _Long.fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
+        return div.toString(radix) + rem1.toInt().toString(radix);
+      } else
+        return "-" + this.neg().toString(radix);
+    }
+    const radixToPower = _Long.fromNumber(Math.pow(radix, 6), this.unsigned);
+    let rem = this;
+    let result = "";
+    while (true) {
+      const remDiv = rem.div(radixToPower);
+      const intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0;
+      let digits = intval.toString(radix);
+      rem = remDiv;
+      if (rem.isZero()) {
+        return digits + result;
+      } else {
+        while (digits.length < 6)
+          digits = "0" + digits;
+        result = "" + digits + result;
+      }
+    }
+  }
+  toUnsigned() {
+    if (this.unsigned)
+      return this;
+    return _Long.fromBits(this.low, this.high, true);
+  }
+  xor(other) {
+    if (!_Long.isLong(other))
+      other = _Long.fromValue(other);
+    return _Long.fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
+  }
+  eqz() {
+    return this.isZero();
+  }
+  le(other) {
+    return this.lessThanOrEqual(other);
+  }
+  toExtendedJSON(options) {
+    if (options && options.relaxed)
+      return this.toNumber();
+    return { $numberLong: this.toString() };
+  }
+  static fromExtendedJSON(doc, options) {
+    const { useBigInt64 = false, relaxed = true } = { ...options };
+    if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) {
+      throw new BSONError("$numberLong string is too long");
+    }
+    if (!DECIMAL_REG_EX.test(doc.$numberLong)) {
+      throw new BSONError(`$numberLong string "${doc.$numberLong}" is in an invalid format`);
+    }
+    if (useBigInt64) {
+      const bigIntResult = BigInt(doc.$numberLong);
+      return BigInt.asIntN(64, bigIntResult);
+    }
+    const longResult = _Long.fromString(doc.$numberLong);
+    if (relaxed) {
+      return longResult.toNumber();
+    }
+    return longResult;
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    const longVal = inspect(this.toString(), options);
+    const unsignedVal = this.unsigned ? `, ${inspect(this.unsigned, options)}` : "";
+    return `new Long(${longVal}${unsignedVal})`;
+  }
+};
+__name(_Long, "Long");
+var Long = _Long;
+Long.TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
+Long.MAX_UNSIGNED_VALUE = Long.fromBits(4294967295 | 0, 4294967295 | 0, true);
+Long.ZERO = Long.fromInt(0);
+Long.UZERO = Long.fromInt(0, true);
+Long.ONE = Long.fromInt(1);
+Long.UONE = Long.fromInt(1, true);
+Long.NEG_ONE = Long.fromInt(-1);
+Long.MAX_VALUE = Long.fromBits(4294967295 | 0, 2147483647 | 0, false);
+Long.MIN_VALUE = Long.fromBits(0, 2147483648 | 0, false);
+var PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
+var PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
+var PARSE_NAN_REGEXP = /^(\+|-)?NaN$/i;
+var EXPONENT_MAX = 6111;
+var EXPONENT_MIN = -6176;
+var EXPONENT_BIAS = 6176;
+var MAX_DIGITS = 34;
+var NAN_BUFFER = ByteUtils.fromNumberArray([
+  124,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0
+].reverse());
+var INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray([
+  248,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0
+].reverse());
+var INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray([
+  120,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0
+].reverse());
+var EXPONENT_REGEX = /^([-+])?(\d+)?$/;
+var COMBINATION_MASK = 31;
+var EXPONENT_MASK = 16383;
+var COMBINATION_INFINITY = 30;
+var COMBINATION_NAN = 31;
+function isDigit(value) {
+  return !isNaN(parseInt(value, 10));
+}
+__name(isDigit, "isDigit");
+function divideu128(value) {
+  const DIVISOR = Long.fromNumber(1e3 * 1e3 * 1e3);
+  let _rem = Long.fromNumber(0);
+  if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {
+    return { quotient: value, rem: _rem };
+  }
+  for (let i = 0; i <= 3; i++) {
+    _rem = _rem.shiftLeft(32);
+    _rem = _rem.add(new Long(value.parts[i], 0));
+    value.parts[i] = _rem.div(DIVISOR).low;
+    _rem = _rem.modulo(DIVISOR);
+  }
+  return { quotient: value, rem: _rem };
+}
+__name(divideu128, "divideu128");
+function multiply64x2(left, right) {
+  if (!left && !right) {
+    return { high: Long.fromNumber(0), low: Long.fromNumber(0) };
+  }
+  const leftHigh = left.shiftRightUnsigned(32);
+  const leftLow = new Long(left.getLowBits(), 0);
+  const rightHigh = right.shiftRightUnsigned(32);
+  const rightLow = new Long(right.getLowBits(), 0);
+  let productHigh = leftHigh.multiply(rightHigh);
+  let productMid = leftHigh.multiply(rightLow);
+  const productMid2 = leftLow.multiply(rightHigh);
+  let productLow = leftLow.multiply(rightLow);
+  productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
+  productMid = new Long(productMid.getLowBits(), 0).add(productMid2).add(productLow.shiftRightUnsigned(32));
+  productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
+  productLow = productMid.shiftLeft(32).add(new Long(productLow.getLowBits(), 0));
+  return { high: productHigh, low: productLow };
+}
+__name(multiply64x2, "multiply64x2");
+function lessThan(left, right) {
+  const uhleft = left.high >>> 0;
+  const uhright = right.high >>> 0;
+  if (uhleft < uhright) {
+    return true;
+  } else if (uhleft === uhright) {
+    const ulleft = left.low >>> 0;
+    const ulright = right.low >>> 0;
+    if (ulleft < ulright)
+      return true;
+  }
+  return false;
+}
+__name(lessThan, "lessThan");
+function invalidErr(string, message) {
+  throw new BSONError(`"${string}" is not a valid Decimal128 string - ${message}`);
+}
+__name(invalidErr, "invalidErr");
+var _Decimal128 = class _Decimal128 extends BSONValue {
+  get _bsontype() {
+    return "Decimal128";
+  }
+  constructor(bytes) {
+    super();
+    if (typeof bytes === "string") {
+      this.bytes = _Decimal128.fromString(bytes).bytes;
+    } else if (bytes instanceof Uint8Array || isUint8Array(bytes)) {
+      if (bytes.byteLength !== 16) {
+        throw new BSONError("Decimal128 must take a Buffer of 16 bytes");
+      }
+      this.bytes = bytes;
+    } else {
+      throw new BSONError("Decimal128 must take a Buffer or string");
+    }
+  }
+  static fromString(representation) {
+    return _Decimal128._fromString(representation, { allowRounding: false });
+  }
+  static fromStringWithRounding(representation) {
+    return _Decimal128._fromString(representation, { allowRounding: true });
+  }
+  static _fromString(representation, options) {
+    let isNegative = false;
+    let sawSign = false;
+    let sawRadix = false;
+    let foundNonZero = false;
+    let significantDigits = 0;
+    let nDigitsRead = 0;
+    let nDigits = 0;
+    let radixPosition = 0;
+    let firstNonZero = 0;
+    const digits = [0];
+    let nDigitsStored = 0;
+    let digitsInsert = 0;
+    let lastDigit = 0;
+    let exponent = 0;
+    let significandHigh = new Long(0, 0);
+    let significandLow = new Long(0, 0);
+    let biasedExponent = 0;
+    let index = 0;
+    if (representation.length >= 7e3) {
+      throw new BSONError("" + representation + " not a valid Decimal128 string");
+    }
+    const stringMatch = representation.match(PARSE_STRING_REGEXP);
+    const infMatch = representation.match(PARSE_INF_REGEXP);
+    const nanMatch = representation.match(PARSE_NAN_REGEXP);
+    if (!stringMatch && !infMatch && !nanMatch || representation.length === 0) {
+      throw new BSONError("" + representation + " not a valid Decimal128 string");
+    }
+    if (stringMatch) {
+      const unsignedNumber = stringMatch[2];
+      const e = stringMatch[4];
+      const expSign = stringMatch[5];
+      const expNumber = stringMatch[6];
+      if (e && expNumber === void 0)
+        invalidErr(representation, "missing exponent power");
+      if (e && unsignedNumber === void 0)
+        invalidErr(representation, "missing exponent base");
+      if (e === void 0 && (expSign || expNumber)) {
+        invalidErr(representation, "missing e before exponent");
+      }
+    }
+    if (representation[index] === "+" || representation[index] === "-") {
+      sawSign = true;
+      isNegative = representation[index++] === "-";
+    }
+    if (!isDigit(representation[index]) && representation[index] !== ".") {
+      if (representation[index] === "i" || representation[index] === "I") {
+        return new _Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
+      } else if (representation[index] === "N") {
+        return new _Decimal128(NAN_BUFFER);
+      }
+    }
+    while (isDigit(representation[index]) || representation[index] === ".") {
+      if (representation[index] === ".") {
+        if (sawRadix)
+          invalidErr(representation, "contains multiple periods");
+        sawRadix = true;
+        index = index + 1;
+        continue;
+      }
+      if (nDigitsStored < MAX_DIGITS) {
+        if (representation[index] !== "0" || foundNonZero) {
+          if (!foundNonZero) {
+            firstNonZero = nDigitsRead;
+          }
+          foundNonZero = true;
+          digits[digitsInsert++] = parseInt(representation[index], 10);
+          nDigitsStored = nDigitsStored + 1;
+        }
+      }
+      if (foundNonZero)
+        nDigits = nDigits + 1;
+      if (sawRadix)
+        radixPosition = radixPosition + 1;
+      nDigitsRead = nDigitsRead + 1;
+      index = index + 1;
+    }
+    if (sawRadix && !nDigitsRead)
+      throw new BSONError("" + representation + " not a valid Decimal128 string");
+    if (representation[index] === "e" || representation[index] === "E") {
+      const match = representation.substr(++index).match(EXPONENT_REGEX);
+      if (!match || !match[2])
+        return new _Decimal128(NAN_BUFFER);
+      exponent = parseInt(match[0], 10);
+      index = index + match[0].length;
+    }
+    if (representation[index])
+      return new _Decimal128(NAN_BUFFER);
+    if (!nDigitsStored) {
+      digits[0] = 0;
+      nDigits = 1;
+      nDigitsStored = 1;
+      significantDigits = 0;
+    } else {
+      lastDigit = nDigitsStored - 1;
+      significantDigits = nDigits;
+      if (significantDigits !== 1) {
+        while (representation[firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)] === "0") {
+          significantDigits = significantDigits - 1;
+        }
+      }
+    }
+    if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) {
+      exponent = EXPONENT_MIN;
+    } else {
+      exponent = exponent - radixPosition;
+    }
+    while (exponent > EXPONENT_MAX) {
+      lastDigit = lastDigit + 1;
+      if (lastDigit >= MAX_DIGITS) {
+        if (significantDigits === 0) {
+          exponent = EXPONENT_MAX;
+          break;
+        }
+        invalidErr(representation, "overflow");
+      }
+      exponent = exponent - 1;
+    }
+    if (options.allowRounding) {
+      while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
+        if (lastDigit === 0 && significantDigits < nDigitsStored) {
+          exponent = EXPONENT_MIN;
+          significantDigits = 0;
+          break;
+        }
+        if (nDigitsStored < nDigits) {
+          nDigits = nDigits - 1;
+        } else {
+          lastDigit = lastDigit - 1;
+        }
+        if (exponent < EXPONENT_MAX) {
+          exponent = exponent + 1;
+        } else {
+          const digitsString = digits.join("");
+          if (digitsString.match(/^0+$/)) {
+            exponent = EXPONENT_MAX;
+            break;
+          }
+          invalidErr(representation, "overflow");
+        }
+      }
+      if (lastDigit + 1 < significantDigits) {
+        let endOfString = nDigitsRead;
+        if (sawRadix) {
+          firstNonZero = firstNonZero + 1;
+          endOfString = endOfString + 1;
+        }
+        if (sawSign) {
+          firstNonZero = firstNonZero + 1;
+          endOfString = endOfString + 1;
+        }
+        const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
+        let roundBit = 0;
+        if (roundDigit >= 5) {
+          roundBit = 1;
+          if (roundDigit === 5) {
+            roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;
+            for (let i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
+              if (parseInt(representation[i], 10)) {
+                roundBit = 1;
+                break;
+              }
+            }
+          }
+        }
+        if (roundBit) {
+          let dIdx = lastDigit;
+          for (; dIdx >= 0; dIdx--) {
+            if (++digits[dIdx] > 9) {
+              digits[dIdx] = 0;
+              if (dIdx === 0) {
+                if (exponent < EXPONENT_MAX) {
+                  exponent = exponent + 1;
+                  digits[dIdx] = 1;
+                } else {
+                  return new _Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
+                }
+              }
+            } else {
+              break;
+            }
+          }
+        }
+      }
+    } else {
+      while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
+        if (lastDigit === 0) {
+          if (significantDigits === 0) {
+            exponent = EXPONENT_MIN;
+            break;
+          }
+          invalidErr(representation, "exponent underflow");
+        }
+        if (nDigitsStored < nDigits) {
+          if (representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== "0" && significantDigits !== 0) {
+            invalidErr(representation, "inexact rounding");
+          }
+          nDigits = nDigits - 1;
+        } else {
+          if (digits[lastDigit] !== 0) {
+            invalidErr(representation, "inexact rounding");
+          }
+          lastDigit = lastDigit - 1;
+        }
+        if (exponent < EXPONENT_MAX) {
+          exponent = exponent + 1;
+        } else {
+          invalidErr(representation, "overflow");
+        }
+      }
+      if (lastDigit + 1 < significantDigits) {
+        if (sawRadix) {
+          firstNonZero = firstNonZero + 1;
+        }
+        if (sawSign) {
+          firstNonZero = firstNonZero + 1;
+        }
+        const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
+        if (roundDigit !== 0) {
+          invalidErr(representation, "inexact rounding");
+        }
+      }
+    }
+    significandHigh = Long.fromNumber(0);
+    significandLow = Long.fromNumber(0);
+    if (significantDigits === 0) {
+      significandHigh = Long.fromNumber(0);
+      significandLow = Long.fromNumber(0);
+    } else if (lastDigit < 17) {
+      let dIdx = 0;
+      significandLow = Long.fromNumber(digits[dIdx++]);
+      significandHigh = new Long(0, 0);
+      for (; dIdx <= lastDigit; dIdx++) {
+        significandLow = significandLow.multiply(Long.fromNumber(10));
+        significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
+      }
+    } else {
+      let dIdx = 0;
+      significandHigh = Long.fromNumber(digits[dIdx++]);
+      for (; dIdx <= lastDigit - 17; dIdx++) {
+        significandHigh = significandHigh.multiply(Long.fromNumber(10));
+        significandHigh = significandHigh.add(Long.fromNumber(digits[dIdx]));
+      }
+      significandLow = Long.fromNumber(digits[dIdx++]);
+      for (; dIdx <= lastDigit; dIdx++) {
+        significandLow = significandLow.multiply(Long.fromNumber(10));
+        significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
+      }
+    }
+    const significand = multiply64x2(significandHigh, Long.fromString("100000000000000000"));
+    significand.low = significand.low.add(significandLow);
+    if (lessThan(significand.low, significandLow)) {
+      significand.high = significand.high.add(Long.fromNumber(1));
+    }
+    biasedExponent = exponent + EXPONENT_BIAS;
+    const dec = { low: Long.fromNumber(0), high: Long.fromNumber(0) };
+    if (significand.high.shiftRightUnsigned(49).and(Long.fromNumber(1)).equals(Long.fromNumber(1))) {
+      dec.high = dec.high.or(Long.fromNumber(3).shiftLeft(61));
+      dec.high = dec.high.or(Long.fromNumber(biasedExponent).and(Long.fromNumber(16383).shiftLeft(47)));
+      dec.high = dec.high.or(significand.high.and(Long.fromNumber(140737488355327)));
+    } else {
+      dec.high = dec.high.or(Long.fromNumber(biasedExponent & 16383).shiftLeft(49));
+      dec.high = dec.high.or(significand.high.and(Long.fromNumber(562949953421311)));
+    }
+    dec.low = significand.low;
+    if (isNegative) {
+      dec.high = dec.high.or(Long.fromString("9223372036854775808"));
+    }
+    const buffer2 = ByteUtils.allocateUnsafe(16);
+    index = 0;
+    buffer2[index++] = dec.low.low & 255;
+    buffer2[index++] = dec.low.low >> 8 & 255;
+    buffer2[index++] = dec.low.low >> 16 & 255;
+    buffer2[index++] = dec.low.low >> 24 & 255;
+    buffer2[index++] = dec.low.high & 255;
+    buffer2[index++] = dec.low.high >> 8 & 255;
+    buffer2[index++] = dec.low.high >> 16 & 255;
+    buffer2[index++] = dec.low.high >> 24 & 255;
+    buffer2[index++] = dec.high.low & 255;
+    buffer2[index++] = dec.high.low >> 8 & 255;
+    buffer2[index++] = dec.high.low >> 16 & 255;
+    buffer2[index++] = dec.high.low >> 24 & 255;
+    buffer2[index++] = dec.high.high & 255;
+    buffer2[index++] = dec.high.high >> 8 & 255;
+    buffer2[index++] = dec.high.high >> 16 & 255;
+    buffer2[index++] = dec.high.high >> 24 & 255;
+    return new _Decimal128(buffer2);
+  }
+  toString() {
+    let biased_exponent;
+    let significand_digits = 0;
+    const significand = new Array(36);
+    for (let i = 0; i < significand.length; i++)
+      significand[i] = 0;
+    let index = 0;
+    let is_zero = false;
+    let significand_msb;
+    let significand128 = { parts: [0, 0, 0, 0] };
+    let j, k;
+    const string = [];
+    index = 0;
+    const buffer2 = this.bytes;
+    const low = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24;
+    const midl = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24;
+    const midh = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24;
+    const high = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24;
+    index = 0;
+    const dec = {
+      low: new Long(low, midl),
+      high: new Long(midh, high)
+    };
+    if (dec.high.lessThan(Long.ZERO)) {
+      string.push("-");
+    }
+    const combination = high >> 26 & COMBINATION_MASK;
+    if (combination >> 3 === 3) {
+      if (combination === COMBINATION_INFINITY) {
+        return string.join("") + "Infinity";
+      } else if (combination === COMBINATION_NAN) {
+        return "NaN";
+      } else {
+        biased_exponent = high >> 15 & EXPONENT_MASK;
+        significand_msb = 8 + (high >> 14 & 1);
+      }
+    } else {
+      significand_msb = high >> 14 & 7;
+      biased_exponent = high >> 17 & EXPONENT_MASK;
+    }
+    const exponent = biased_exponent - EXPONENT_BIAS;
+    significand128.parts[0] = (high & 16383) + ((significand_msb & 15) << 14);
+    significand128.parts[1] = midh;
+    significand128.parts[2] = midl;
+    significand128.parts[3] = low;
+    if (significand128.parts[0] === 0 && significand128.parts[1] === 0 && significand128.parts[2] === 0 && significand128.parts[3] === 0) {
+      is_zero = true;
+    } else {
+      for (k = 3; k >= 0; k--) {
+        let least_digits = 0;
+        const result = divideu128(significand128);
+        significand128 = result.quotient;
+        least_digits = result.rem.low;
+        if (!least_digits)
+          continue;
+        for (j = 8; j >= 0; j--) {
+          significand[k * 9 + j] = least_digits % 10;
+          least_digits = Math.floor(least_digits / 10);
+        }
+      }
+    }
+    if (is_zero) {
+      significand_digits = 1;
+      significand[index] = 0;
+    } else {
+      significand_digits = 36;
+      while (!significand[index]) {
+        significand_digits = significand_digits - 1;
+        index = index + 1;
+      }
+    }
+    const scientific_exponent = significand_digits - 1 + exponent;
+    if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {
+      if (significand_digits > 34) {
+        string.push(`${0}`);
+        if (exponent > 0)
+          string.push(`E+${exponent}`);
+        else if (exponent < 0)
+          string.push(`E${exponent}`);
+        return string.join("");
+      }
+      string.push(`${significand[index++]}`);
+      significand_digits = significand_digits - 1;
+      if (significand_digits) {
+        string.push(".");
+      }
+      for (let i = 0; i < significand_digits; i++) {
+        string.push(`${significand[index++]}`);
+      }
+      string.push("E");
+      if (scientific_exponent > 0) {
+        string.push(`+${scientific_exponent}`);
+      } else {
+        string.push(`${scientific_exponent}`);
+      }
+    } else {
+      if (exponent >= 0) {
+        for (let i = 0; i < significand_digits; i++) {
+          string.push(`${significand[index++]}`);
+        }
+      } else {
+        let radix_position = significand_digits + exponent;
+        if (radix_position > 0) {
+          for (let i = 0; i < radix_position; i++) {
+            string.push(`${significand[index++]}`);
+          }
+        } else {
+          string.push("0");
+        }
+        string.push(".");
+        while (radix_position++ < 0) {
+          string.push("0");
+        }
+        for (let i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) {
+          string.push(`${significand[index++]}`);
+        }
+      }
+    }
+    return string.join("");
+  }
+  toJSON() {
+    return { $numberDecimal: this.toString() };
+  }
+  toExtendedJSON() {
+    return { $numberDecimal: this.toString() };
+  }
+  static fromExtendedJSON(doc) {
+    return _Decimal128.fromString(doc.$numberDecimal);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    const d128string = inspect(this.toString(), options);
+    return `new Decimal128(${d128string})`;
+  }
+};
+__name(_Decimal128, "Decimal128");
+var Decimal128 = _Decimal128;
+var _Double = class _Double extends BSONValue {
+  get _bsontype() {
+    return "Double";
+  }
+  constructor(value) {
+    super();
+    if (value instanceof Number) {
+      value = value.valueOf();
+    }
+    this.value = +value;
+  }
+  static fromString(value) {
+    const coercedValue = Number(value);
+    if (value === "NaN")
+      return new _Double(NaN);
+    if (value === "Infinity")
+      return new _Double(Infinity);
+    if (value === "-Infinity")
+      return new _Double(-Infinity);
+    if (!Number.isFinite(coercedValue)) {
+      throw new BSONError(`Input: ${value} is not representable as a Double`);
+    }
+    if (value.trim() !== value) {
+      throw new BSONError(`Input: '${value}' contains whitespace`);
+    }
+    if (value === "") {
+      throw new BSONError(`Input is an empty string`);
+    }
+    if (/[^-0-9.+eE]/.test(value)) {
+      throw new BSONError(`Input: '${value}' is not in decimal or exponential notation`);
+    }
+    return new _Double(coercedValue);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+  toString(radix) {
+    return this.value.toString(radix);
+  }
+  toExtendedJSON(options) {
+    if (options && (options.legacy || options.relaxed && isFinite(this.value))) {
+      return this.value;
+    }
+    if (Object.is(Math.sign(this.value), -0)) {
+      return { $numberDouble: "-0.0" };
+    }
+    return {
+      $numberDouble: Number.isInteger(this.value) ? this.value.toFixed(1) : this.value.toString()
+    };
+  }
+  static fromExtendedJSON(doc, options) {
+    const doubleValue = parseFloat(doc.$numberDouble);
+    return options && options.relaxed ? doubleValue : new _Double(doubleValue);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    return `new Double(${inspect(this.value, options)})`;
+  }
+};
+__name(_Double, "Double");
+var Double = _Double;
+var _Int32 = class _Int32 extends BSONValue {
+  get _bsontype() {
+    return "Int32";
+  }
+  constructor(value) {
+    super();
+    if (value instanceof Number) {
+      value = value.valueOf();
+    }
+    this.value = +value | 0;
+  }
+  static fromString(value) {
+    const cleanedValue = removeLeadingZerosAndExplicitPlus(value);
+    const coercedValue = Number(value);
+    if (BSON_INT32_MAX < coercedValue) {
+      throw new BSONError(`Input: '${value}' is larger than the maximum value for Int32`);
+    } else if (BSON_INT32_MIN > coercedValue) {
+      throw new BSONError(`Input: '${value}' is smaller than the minimum value for Int32`);
+    } else if (!Number.isSafeInteger(coercedValue)) {
+      throw new BSONError(`Input: '${value}' is not a safe integer`);
+    } else if (coercedValue.toString() !== cleanedValue) {
+      throw new BSONError(`Input: '${value}' is not a valid Int32 string`);
+    }
+    return new _Int32(coercedValue);
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString(radix) {
+    return this.value.toString(radix);
+  }
+  toJSON() {
+    return this.value;
+  }
+  toExtendedJSON(options) {
+    if (options && (options.relaxed || options.legacy))
+      return this.value;
+    return { $numberInt: this.value.toString() };
+  }
+  static fromExtendedJSON(doc, options) {
+    return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new _Int32(doc.$numberInt);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    return `new Int32(${inspect(this.value, options)})`;
+  }
+};
+__name(_Int32, "Int32");
+var Int32 = _Int32;
+var _MaxKey = class _MaxKey extends BSONValue {
+  get _bsontype() {
+    return "MaxKey";
+  }
+  toExtendedJSON() {
+    return { $maxKey: 1 };
+  }
+  static fromExtendedJSON() {
+    return new _MaxKey();
+  }
+  inspect() {
+    return "new MaxKey()";
+  }
+};
+__name(_MaxKey, "MaxKey");
+var MaxKey = _MaxKey;
+var _MinKey = class _MinKey extends BSONValue {
+  get _bsontype() {
+    return "MinKey";
+  }
+  toExtendedJSON() {
+    return { $minKey: 1 };
+  }
+  static fromExtendedJSON() {
+    return new _MinKey();
+  }
+  inspect() {
+    return "new MinKey()";
+  }
+};
+__name(_MinKey, "MinKey");
+var MinKey = _MinKey;
+var PROCESS_UNIQUE = null;
+var __idCache = /* @__PURE__ */ new WeakMap();
+var _ObjectId = class _ObjectId extends BSONValue {
+  get _bsontype() {
+    return "ObjectId";
+  }
+  constructor(inputId) {
+    super();
+    let workingId;
+    if (typeof inputId === "object" && inputId && "id" in inputId) {
+      if (typeof inputId.id !== "string" && !ArrayBuffer.isView(inputId.id)) {
+        throw new BSONError("Argument passed in must have an id that is of type string or Buffer");
+      }
+      if ("toHexString" in inputId && typeof inputId.toHexString === "function") {
+        workingId = ByteUtils.fromHex(inputId.toHexString());
+      } else {
+        workingId = inputId.id;
+      }
+    } else {
+      workingId = inputId;
+    }
+    if (workingId == null || typeof workingId === "number") {
+      this.buffer = _ObjectId.generate(typeof workingId === "number" ? workingId : void 0);
+    } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) {
+      this.buffer = ByteUtils.toLocalBufferType(workingId);
+    } else if (typeof workingId === "string") {
+      if (_ObjectId.validateHexString(workingId)) {
+        this.buffer = ByteUtils.fromHex(workingId);
+        if (_ObjectId.cacheHexString) {
+          __idCache.set(this, workingId);
+        }
+      } else {
+        throw new BSONError("input must be a 24 character hex string, 12 byte Uint8Array, or an integer");
+      }
+    } else {
+      throw new BSONError("Argument passed in does not match the accepted types");
+    }
+  }
+  get id() {
+    return this.buffer;
+  }
+  set id(value) {
+    this.buffer = value;
+    if (_ObjectId.cacheHexString) {
+      __idCache.set(this, ByteUtils.toHex(value));
+    }
+  }
+  static validateHexString(string) {
+    if (string?.length !== 24)
+      return false;
+    for (let i = 0; i < 24; i++) {
+      const char = string.charCodeAt(i);
+      if (char >= 48 && char <= 57 || char >= 97 && char <= 102 || char >= 65 && char <= 70) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+  toHexString() {
+    if (_ObjectId.cacheHexString) {
+      const __id = __idCache.get(this);
+      if (__id)
+        return __id;
+    }
+    const hexString = ByteUtils.toHex(this.id);
+    if (_ObjectId.cacheHexString) {
+      __idCache.set(this, hexString);
+    }
+    return hexString;
+  }
+  static getInc() {
+    return _ObjectId.index = (_ObjectId.index + 1) % 16777215;
+  }
+  static generate(time) {
+    if ("number" !== typeof time) {
+      time = Math.floor(Date.now() / 1e3);
+    }
+    const inc = _ObjectId.getInc();
+    const buffer2 = ByteUtils.allocateUnsafe(12);
+    NumberUtils.setInt32BE(buffer2, 0, time);
+    if (PROCESS_UNIQUE === null) {
+      PROCESS_UNIQUE = ByteUtils.randomBytes(5);
+    }
+    buffer2[4] = PROCESS_UNIQUE[0];
+    buffer2[5] = PROCESS_UNIQUE[1];
+    buffer2[6] = PROCESS_UNIQUE[2];
+    buffer2[7] = PROCESS_UNIQUE[3];
+    buffer2[8] = PROCESS_UNIQUE[4];
+    buffer2[11] = inc & 255;
+    buffer2[10] = inc >> 8 & 255;
+    buffer2[9] = inc >> 16 & 255;
+    return buffer2;
+  }
+  toString(encoding) {
+    if (encoding === "base64")
+      return ByteUtils.toBase64(this.id);
+    if (encoding === "hex")
+      return this.toHexString();
+    return this.toHexString();
+  }
+  toJSON() {
+    return this.toHexString();
+  }
+  static is(variable) {
+    return variable != null && typeof variable === "object" && "_bsontype" in variable && variable._bsontype === "ObjectId";
+  }
+  equals(otherId) {
+    if (otherId === void 0 || otherId === null) {
+      return false;
+    }
+    if (_ObjectId.is(otherId)) {
+      return this.buffer[11] === otherId.buffer[11] && ByteUtils.equals(this.buffer, otherId.buffer);
+    }
+    if (typeof otherId === "string") {
+      return otherId.toLowerCase() === this.toHexString();
+    }
+    if (typeof otherId === "object" && typeof otherId.toHexString === "function") {
+      const otherIdString = otherId.toHexString();
+      const thisIdString = this.toHexString();
+      return typeof otherIdString === "string" && otherIdString.toLowerCase() === thisIdString;
+    }
+    return false;
+  }
+  getTimestamp() {
+    const timestamp = /* @__PURE__ */ new Date();
+    const time = NumberUtils.getUint32BE(this.buffer, 0);
+    timestamp.setTime(Math.floor(time) * 1e3);
+    return timestamp;
+  }
+  static createPk() {
+    return new _ObjectId();
+  }
+  serializeInto(uint8array, index) {
+    uint8array[index] = this.buffer[0];
+    uint8array[index + 1] = this.buffer[1];
+    uint8array[index + 2] = this.buffer[2];
+    uint8array[index + 3] = this.buffer[3];
+    uint8array[index + 4] = this.buffer[4];
+    uint8array[index + 5] = this.buffer[5];
+    uint8array[index + 6] = this.buffer[6];
+    uint8array[index + 7] = this.buffer[7];
+    uint8array[index + 8] = this.buffer[8];
+    uint8array[index + 9] = this.buffer[9];
+    uint8array[index + 10] = this.buffer[10];
+    uint8array[index + 11] = this.buffer[11];
+    return 12;
+  }
+  static createFromTime(time) {
+    const buffer2 = ByteUtils.allocate(12);
+    for (let i = 11; i >= 4; i--)
+      buffer2[i] = 0;
+    NumberUtils.setInt32BE(buffer2, 0, time);
+    return new _ObjectId(buffer2);
+  }
+  static createFromHexString(hexString) {
+    if (hexString?.length !== 24) {
+      throw new BSONError("hex string must be 24 characters");
+    }
+    return new _ObjectId(ByteUtils.fromHex(hexString));
+  }
+  static createFromBase64(base64) {
+    if (base64?.length !== 16) {
+      throw new BSONError("base64 string must be 16 characters");
+    }
+    return new _ObjectId(ByteUtils.fromBase64(base64));
+  }
+  static isValid(id) {
+    if (id == null)
+      return false;
+    if (typeof id === "string")
+      return _ObjectId.validateHexString(id);
+    try {
+      new _ObjectId(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  toExtendedJSON() {
+    if (this.toHexString)
+      return { $oid: this.toHexString() };
+    return { $oid: this.toString("hex") };
+  }
+  static fromExtendedJSON(doc) {
+    return new _ObjectId(doc.$oid);
+  }
+  isCached() {
+    return _ObjectId.cacheHexString && __idCache.has(this);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    return `new ObjectId(${inspect(this.toHexString(), options)})`;
+  }
+};
+__name(_ObjectId, "ObjectId");
+var ObjectId = _ObjectId;
+ObjectId.index = Math.floor(Math.random() * 16777215);
+function alphabetize(str) {
+  return str.split("").sort().join("");
+}
+__name(alphabetize, "alphabetize");
+var _BSONRegExp = class _BSONRegExp extends BSONValue {
+  get _bsontype() {
+    return "BSONRegExp";
+  }
+  constructor(pattern, options) {
+    super();
+    this.pattern = pattern;
+    this.options = alphabetize(options ?? "");
+    if (this.pattern.indexOf("\0") !== -1) {
+      throw new BSONError(`BSON Regex patterns cannot contain null bytes, found: ${JSON.stringify(this.pattern)}`);
+    }
+    if (this.options.indexOf("\0") !== -1) {
+      throw new BSONError(`BSON Regex options cannot contain null bytes, found: ${JSON.stringify(this.options)}`);
+    }
+    for (let i = 0; i < this.options.length; i++) {
+      if (!(this.options[i] === "i" || this.options[i] === "m" || this.options[i] === "x" || this.options[i] === "l" || this.options[i] === "s" || this.options[i] === "u")) {
+        throw new BSONError(`The regular expression option [${this.options[i]}] is not supported`);
+      }
+    }
+  }
+  static parseOptions(options) {
+    return options ? options.split("").sort().join("") : "";
+  }
+  toExtendedJSON(options) {
+    options = options || {};
+    if (options.legacy) {
+      return { $regex: this.pattern, $options: this.options };
+    }
+    return { $regularExpression: { pattern: this.pattern, options: this.options } };
+  }
+  static fromExtendedJSON(doc) {
+    if ("$regex" in doc) {
+      if (typeof doc.$regex !== "string") {
+        if (doc.$regex._bsontype === "BSONRegExp") {
+          return doc;
+        }
+      } else {
+        return new _BSONRegExp(doc.$regex, _BSONRegExp.parseOptions(doc.$options));
+      }
+    }
+    if ("$regularExpression" in doc) {
+      return new _BSONRegExp(doc.$regularExpression.pattern, _BSONRegExp.parseOptions(doc.$regularExpression.options));
+    }
+    throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
+  }
+  inspect(depth, options, inspect) {
+    const stylize = getStylizeFunction(options) ?? ((v) => v);
+    inspect ?? (inspect = defaultInspect);
+    const pattern = stylize(inspect(this.pattern), "regexp");
+    const flags = stylize(inspect(this.options), "regexp");
+    return `new BSONRegExp(${pattern}, ${flags})`;
+  }
+};
+__name(_BSONRegExp, "BSONRegExp");
+var BSONRegExp = _BSONRegExp;
+var _BSONSymbol = class _BSONSymbol extends BSONValue {
+  get _bsontype() {
+    return "BSONSymbol";
+  }
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  valueOf() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+  toExtendedJSON() {
+    return { $symbol: this.value };
+  }
+  static fromExtendedJSON(doc) {
+    return new _BSONSymbol(doc.$symbol);
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    return `new BSONSymbol(${inspect(this.value, options)})`;
+  }
+};
+__name(_BSONSymbol, "BSONSymbol");
+var BSONSymbol = _BSONSymbol;
+var LongWithoutOverridesClass = Long;
+var _Timestamp = class _Timestamp extends LongWithoutOverridesClass {
+  get _bsontype() {
+    return "Timestamp";
+  }
+  get i() {
+    return this.low >>> 0;
+  }
+  get t() {
+    return this.high >>> 0;
+  }
+  constructor(low) {
+    if (low == null) {
+      super(0, 0, true);
+    } else if (typeof low === "bigint") {
+      super(low, true);
+    } else if (Long.isLong(low)) {
+      super(low.low, low.high, true);
+    } else if (typeof low === "object" && "t" in low && "i" in low) {
+      if (typeof low.t !== "number" && (typeof low.t !== "object" || low.t._bsontype !== "Int32")) {
+        throw new BSONError("Timestamp constructed from { t, i } must provide t as a number");
+      }
+      if (typeof low.i !== "number" && (typeof low.i !== "object" || low.i._bsontype !== "Int32")) {
+        throw new BSONError("Timestamp constructed from { t, i } must provide i as a number");
+      }
+      const t = Number(low.t);
+      const i = Number(low.i);
+      if (t < 0 || Number.isNaN(t)) {
+        throw new BSONError("Timestamp constructed from { t, i } must provide a positive t");
+      }
+      if (i < 0 || Number.isNaN(i)) {
+        throw new BSONError("Timestamp constructed from { t, i } must provide a positive i");
+      }
+      if (t > 4294967295) {
+        throw new BSONError("Timestamp constructed from { t, i } must provide t equal or less than uint32 max");
+      }
+      if (i > 4294967295) {
+        throw new BSONError("Timestamp constructed from { t, i } must provide i equal or less than uint32 max");
+      }
+      super(i, t, true);
+    } else {
+      throw new BSONError("A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }");
+    }
+  }
+  toJSON() {
+    return {
+      $timestamp: this.toString()
+    };
+  }
+  static fromInt(value) {
+    return new _Timestamp(Long.fromInt(value, true));
+  }
+  static fromNumber(value) {
+    return new _Timestamp(Long.fromNumber(value, true));
+  }
+  static fromBits(lowBits, highBits) {
+    return new _Timestamp({ i: lowBits, t: highBits });
+  }
+  static fromString(str, optRadix) {
+    return new _Timestamp(Long.fromString(str, true, optRadix));
+  }
+  toExtendedJSON() {
+    return { $timestamp: { t: this.t, i: this.i } };
+  }
+  static fromExtendedJSON(doc) {
+    const i = Long.isLong(doc.$timestamp.i) ? doc.$timestamp.i.getLowBitsUnsigned() : doc.$timestamp.i;
+    const t = Long.isLong(doc.$timestamp.t) ? doc.$timestamp.t.getLowBitsUnsigned() : doc.$timestamp.t;
+    return new _Timestamp({ t, i });
+  }
+  inspect(depth, options, inspect) {
+    inspect ?? (inspect = defaultInspect);
+    const t = inspect(this.t, options);
+    const i = inspect(this.i, options);
+    return `new Timestamp({ t: ${t}, i: ${i} })`;
+  }
+};
+__name(_Timestamp, "Timestamp");
+var Timestamp = _Timestamp;
+Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
+var JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX);
+var JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN);
+function isBSONType(value) {
+  return value != null && typeof value === "object" && "_bsontype" in value && typeof value._bsontype === "string";
+}
+__name(isBSONType, "isBSONType");
+var keysToCodecs = {
+  $oid: ObjectId,
+  $binary: Binary,
+  $uuid: Binary,
+  $symbol: BSONSymbol,
+  $numberInt: Int32,
+  $numberDecimal: Decimal128,
+  $numberDouble: Double,
+  $numberLong: Long,
+  $minKey: MinKey,
+  $maxKey: MaxKey,
+  $regex: BSONRegExp,
+  $regularExpression: BSONRegExp,
+  $timestamp: Timestamp
+};
+function deserializeValue(value, options = {}) {
+  if (typeof value === "number") {
+    const in32BitRange = value <= BSON_INT32_MAX && value >= BSON_INT32_MIN;
+    const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN;
+    if (options.relaxed || options.legacy) {
+      return value;
+    }
+    if (Number.isInteger(value) && !Object.is(value, -0)) {
+      if (in32BitRange) {
+        return new Int32(value);
+      }
+      if (in64BitRange) {
+        if (options.useBigInt64) {
+          return BigInt(value);
+        }
+        return Long.fromNumber(value);
+      }
+    }
+    return new Double(value);
+  }
+  if (value == null || typeof value !== "object")
+    return value;
+  if (value.$undefined)
+    return null;
+  const keys = Object.keys(value).filter((k) => k.startsWith("$") && value[k] != null);
+  for (let i = 0; i < keys.length; i++) {
+    const c = keysToCodecs[keys[i]];
+    if (c)
+      return c.fromExtendedJSON(value, options);
+  }
+  if (value.$date != null) {
+    const d = value.$date;
+    const date = /* @__PURE__ */ new Date();
+    if (options.legacy) {
+      if (typeof d === "number")
+        date.setTime(d);
+      else if (typeof d === "string")
+        date.setTime(Date.parse(d));
+      else if (typeof d === "bigint")
+        date.setTime(Number(d));
+      else
+        throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);
+    } else {
+      if (typeof d === "string")
+        date.setTime(Date.parse(d));
+      else if (Long.isLong(d))
+        date.setTime(d.toNumber());
+      else if (typeof d === "number" && options.relaxed)
+        date.setTime(d);
+      else if (typeof d === "bigint")
+        date.setTime(Number(d));
+      else
+        throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);
+    }
+    return date;
+  }
+  if (value.$code != null) {
+    const copy = Object.assign({}, value);
+    if (value.$scope) {
+      copy.$scope = deserializeValue(value.$scope);
+    }
+    return Code.fromExtendedJSON(value);
+  }
+  if (isDBRefLike(value) || value.$dbPointer) {
+    const v = value.$ref ? value : value.$dbPointer;
+    if (v instanceof DBRef)
+      return v;
+    const dollarKeys = Object.keys(v).filter((k) => k.startsWith("$"));
+    let valid = true;
+    dollarKeys.forEach((k) => {
+      if (["$ref", "$id", "$db"].indexOf(k) === -1)
+        valid = false;
+    });
+    if (valid)
+      return DBRef.fromExtendedJSON(v);
+  }
+  return value;
+}
+__name(deserializeValue, "deserializeValue");
+function serializeArray(array, options) {
+  return array.map((v, index) => {
+    options.seenObjects.push({ propertyName: `index ${index}`, obj: null });
+    try {
+      return serializeValue(v, options);
+    } finally {
+      options.seenObjects.pop();
+    }
+  });
+}
+__name(serializeArray, "serializeArray");
+function getISOString(date) {
+  const isoStr = date.toISOString();
+  return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + "Z";
+}
+__name(getISOString, "getISOString");
+function serializeValue(value, options) {
+  if (value instanceof Map || isMap(value)) {
+    const obj = /* @__PURE__ */ Object.create(null);
+    for (const [k, v] of value) {
+      if (typeof k !== "string") {
+        throw new BSONError("Can only serialize maps with string keys");
+      }
+      obj[k] = v;
+    }
+    return serializeValue(obj, options);
+  }
+  if ((typeof value === "object" || typeof value === "function") && value !== null) {
+    const index = options.seenObjects.findIndex((entry) => entry.obj === value);
+    if (index !== -1) {
+      const props = options.seenObjects.map((entry) => entry.propertyName);
+      const leadingPart = props.slice(0, index).map((prop) => `${prop} -> `).join("");
+      const alreadySeen = props[index];
+      const circularPart = " -> " + props.slice(index + 1, props.length - 1).map((prop) => `${prop} -> `).join("");
+      const current = props[props.length - 1];
+      const leadingSpace = " ".repeat(leadingPart.length + alreadySeen.length / 2);
+      const dashes = "-".repeat(circularPart.length + (alreadySeen.length + current.length) / 2 - 1);
+      throw new BSONError(`Converting circular structure to EJSON:
+    ${leadingPart}${alreadySeen}${circularPart}${current}
+    ${leadingSpace}\\${dashes}/`);
+    }
+    options.seenObjects[options.seenObjects.length - 1].obj = value;
+  }
+  if (Array.isArray(value))
+    return serializeArray(value, options);
+  if (value === void 0)
+    return null;
+  if (value instanceof Date || isDate(value)) {
+    const dateNum = value.getTime(), inRange = dateNum > -1 && dateNum < 2534023188e5;
+    if (options.legacy) {
+      return options.relaxed && inRange ? { $date: value.getTime() } : { $date: getISOString(value) };
+    }
+    return options.relaxed && inRange ? { $date: getISOString(value) } : { $date: { $numberLong: value.getTime().toString() } };
+  }
+  if (typeof value === "number" && (!options.relaxed || !isFinite(value))) {
+    if (Number.isInteger(value) && !Object.is(value, -0)) {
+      if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) {
+        return { $numberInt: value.toString() };
+      }
+      if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) {
+        return { $numberLong: value.toString() };
+      }
+    }
+    return { $numberDouble: Object.is(value, -0) ? "-0.0" : value.toString() };
+  }
+  if (typeof value === "bigint") {
+    if (!options.relaxed) {
+      return { $numberLong: BigInt.asIntN(64, value).toString() };
+    }
+    return Number(BigInt.asIntN(64, value));
+  }
+  if (value instanceof RegExp || isRegExp(value)) {
+    let flags = value.flags;
+    if (flags === void 0) {
+      const match = value.toString().match(/[gimuy]*$/);
+      if (match) {
+        flags = match[0];
+      }
+    }
+    const rx = new BSONRegExp(value.source, flags);
+    return rx.toExtendedJSON(options);
+  }
+  if (value != null && typeof value === "object")
+    return serializeDocument(value, options);
+  return value;
+}
+__name(serializeValue, "serializeValue");
+var BSON_TYPE_MAPPINGS = {
+  Binary: /* @__PURE__ */ __name((o) => new Binary(o.value(), o.sub_type), "Binary"),
+  Code: /* @__PURE__ */ __name((o) => new Code(o.code, o.scope), "Code"),
+  DBRef: /* @__PURE__ */ __name((o) => new DBRef(o.collection || o.namespace, o.oid, o.db, o.fields), "DBRef"),
+  Decimal128: /* @__PURE__ */ __name((o) => new Decimal128(o.bytes), "Decimal128"),
+  Double: /* @__PURE__ */ __name((o) => new Double(o.value), "Double"),
+  Int32: /* @__PURE__ */ __name((o) => new Int32(o.value), "Int32"),
+  Long: /* @__PURE__ */ __name((o) => Long.fromBits(o.low != null ? o.low : o.low_, o.low != null ? o.high : o.high_, o.low != null ? o.unsigned : o.unsigned_), "Long"),
+  MaxKey: /* @__PURE__ */ __name(() => new MaxKey(), "MaxKey"),
+  MinKey: /* @__PURE__ */ __name(() => new MinKey(), "MinKey"),
+  ObjectId: /* @__PURE__ */ __name((o) => new ObjectId(o), "ObjectId"),
+  BSONRegExp: /* @__PURE__ */ __name((o) => new BSONRegExp(o.pattern, o.options), "BSONRegExp"),
+  BSONSymbol: /* @__PURE__ */ __name((o) => new BSONSymbol(o.value), "BSONSymbol"),
+  Timestamp: /* @__PURE__ */ __name((o) => Timestamp.fromBits(o.low, o.high), "Timestamp")
+};
+function serializeDocument(doc, options) {
+  if (doc == null || typeof doc !== "object")
+    throw new BSONError("not an object instance");
+  const bsontype = doc._bsontype;
+  if (typeof bsontype === "undefined") {
+    const _doc = {};
+    for (const name of Object.keys(doc)) {
+      options.seenObjects.push({ propertyName: name, obj: null });
+      try {
+        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();
+      }
+    }
+    return _doc;
+  } else if (doc != null && typeof doc === "object" && typeof doc._bsontype === "string" && doc[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+    throw new BSONVersionError();
+  } else if (isBSONType(doc)) {
+    let outDoc = doc;
+    if (typeof outDoc.toExtendedJSON !== "function") {
+      const mapper = BSON_TYPE_MAPPINGS[doc._bsontype];
+      if (!mapper) {
+        throw new BSONError("Unrecognized or invalid _bsontype: " + doc._bsontype);
+      }
+      outDoc = mapper(outDoc);
+    }
+    if (bsontype === "Code" && outDoc.scope) {
+      outDoc = new Code(outDoc.code, serializeValue(outDoc.scope, options));
+    } else if (bsontype === "DBRef" && outDoc.oid) {
+      outDoc = new DBRef(serializeValue(outDoc.collection, options), serializeValue(outDoc.oid, options), serializeValue(outDoc.db, options), serializeValue(outDoc.fields, options));
+    }
+    return outDoc.toExtendedJSON(options);
+  } else {
+    throw new BSONError("_bsontype must be a string, but was: " + typeof bsontype);
+  }
+}
+__name(serializeDocument, "serializeDocument");
+function parse2(text, options) {
+  const ejsonOptions = {
+    useBigInt64: options?.useBigInt64 ?? false,
+    relaxed: options?.relaxed ?? true,
+    legacy: options?.legacy ?? false
+  };
+  return JSON.parse(text, (key, value) => {
+    if (key.indexOf("\0") !== -1) {
+      throw new BSONError(`BSON Document field names cannot contain null bytes, found: ${JSON.stringify(key)}`);
+    }
+    return deserializeValue(value, ejsonOptions);
+  });
+}
+__name(parse2, "parse");
+function stringify(value, replacer, space, options) {
+  if (space != null && typeof space === "object") {
+    options = space;
+    space = 0;
+  }
+  if (replacer != null && typeof replacer === "object" && !Array.isArray(replacer)) {
+    options = replacer;
+    replacer = void 0;
+    space = 0;
+  }
+  const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, {
+    seenObjects: [{ propertyName: "(root)", obj: null }]
+  });
+  const doc = serializeValue(value, serializeOptions);
+  return JSON.stringify(doc, replacer, space);
+}
+__name(stringify, "stringify");
+function EJSONserialize(value, options) {
+  options = options || {};
+  return JSON.parse(stringify(value, options));
+}
+__name(EJSONserialize, "EJSONserialize");
+function EJSONdeserialize(ejson, options) {
+  options = options || {};
+  return parse2(JSON.stringify(ejson), options);
+}
+__name(EJSONdeserialize, "EJSONdeserialize");
+var EJSON = /* @__PURE__ */ Object.create(null);
+EJSON.parse = parse2;
+EJSON.stringify = stringify;
+EJSON.serialize = EJSONserialize;
+EJSON.deserialize = EJSONdeserialize;
+Object.freeze(EJSON);
+var 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
+};
+function getSize(source, offset) {
+  try {
+    return NumberUtils.getNonnegativeInt32LE(source, offset);
+  } catch (cause) {
+    throw new BSONOffsetError("BSON size cannot be negative", offset, { cause });
+  }
+}
+__name(getSize, "getSize");
+function findNull(bytes, offset) {
+  let nullTerminatorOffset = offset;
+  for (; bytes[nullTerminatorOffset] !== 0; nullTerminatorOffset++)
+    ;
+  if (nullTerminatorOffset === bytes.length - 1) {
+    throw new BSONOffsetError("Null terminator not found", offset);
+  }
+  return nullTerminatorOffset;
+}
+__name(findNull, "findNull");
+function parseToElements(bytes, startOffset = 0) {
+  startOffset ?? (startOffset = 0);
+  if (bytes.length < 5) {
+    throw new BSONOffsetError(`Input must be at least 5 bytes, got ${bytes.length} bytes`, startOffset);
+  }
+  const documentSize = getSize(bytes, startOffset);
+  if (documentSize > bytes.length - startOffset) {
+    throw new BSONOffsetError(`Parsed documentSize (${documentSize} bytes) does not match input length (${bytes.length} bytes)`, startOffset);
+  }
+  if (bytes[startOffset + documentSize - 1] !== 0) {
+    throw new BSONOffsetError("BSON documents must end in 0x00", startOffset + documentSize);
+  }
+  const elements = [];
+  let offset = startOffset + 4;
+  while (offset <= documentSize + startOffset) {
+    const type = bytes[offset];
+    offset += 1;
+    if (type === 0) {
+      if (offset - startOffset !== documentSize) {
+        throw new BSONOffsetError(`Invalid 0x00 type byte`, offset);
+      }
+      break;
+    }
+    const nameOffset = offset;
+    const nameLength = findNull(bytes, offset) - nameOffset;
+    offset += nameLength + 1;
+    let length;
+    if (type === BSONElementType.double || type === BSONElementType.long || type === BSONElementType.date || type === BSONElementType.timestamp) {
+      length = 8;
+    } else if (type === BSONElementType.int) {
+      length = 4;
+    } else if (type === BSONElementType.objectId) {
+      length = 12;
+    } else if (type === BSONElementType.decimal) {
+      length = 16;
+    } else if (type === BSONElementType.bool) {
+      length = 1;
+    } else if (type === BSONElementType.null || type === BSONElementType.undefined || type === BSONElementType.maxKey || type === BSONElementType.minKey) {
+      length = 0;
+    } else if (type === BSONElementType.regex) {
+      length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset;
+    } else if (type === BSONElementType.object || type === BSONElementType.array || type === BSONElementType.javascriptWithScope) {
+      length = getSize(bytes, offset);
+    } else if (type === BSONElementType.string || type === BSONElementType.binData || type === BSONElementType.dbPointer || type === BSONElementType.javascript || type === BSONElementType.symbol) {
+      length = getSize(bytes, offset) + 4;
+      if (type === BSONElementType.binData) {
+        length += 1;
+      }
+      if (type === BSONElementType.dbPointer) {
+        length += 12;
+      }
+    } else {
+      throw new BSONOffsetError(`Invalid 0x${type.toString(16).padStart(2, "0")} type byte`, offset);
+    }
+    if (length > documentSize) {
+      throw new BSONOffsetError("value reports length larger than document", offset);
+    }
+    elements.push([type, nameOffset, nameLength, offset, length]);
+    offset += length;
+  }
+  return elements;
+}
+__name(parseToElements, "parseToElements");
+var onDemand = /* @__PURE__ */ Object.create(null);
+onDemand.parseToElements = parseToElements;
+onDemand.ByteUtils = ByteUtils;
+onDemand.NumberUtils = NumberUtils;
+Object.freeze(onDemand);
+var MAXSIZE = 1024 * 1024 * 17;
+var buffer = ByteUtils.allocate(MAXSIZE);
+
 // src/framework/abdb/collection/index.ts
 import { init as initDb, DbError } from "@adobe/aio-lib-db";
 
@@ -2831,144 +6002,193 @@ var _AbdbRepository = class _AbdbRepository {
     );
   }
   /**
-   * Returns `true` when a document with the given `_id` exists in the collection.
-   * Uses `countDocuments` rather than fetching the full document for efficiency.
+   * Returns the document with the given `_id`, or `null` if none found.
    *
-   * @param id - The `_id` to check
-   * @returns `true` if the document exists, `false` otherwise
+   * @param id - The `_id` of the document to find (string or ObjectId)
+   * @returns The matched document, or `null`
    */
-  async exists(id) {
-    if (!id) return false;
-    const n = await this._collection.run(
+  async findById(id) {
+    return await this.findOne({ _id: new ObjectId(String(id)) });
+  }
+  /**
+   * Deletes all documents matching `filter` using a single `deleteMany` call.
+   * Passing no filter (or an empty object) deletes every document in the collection.
+   *
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @returns The raw `deleteMany` result document (e.g. `acknowledged`, `deletedCount`)
+   */
+  async delete(filter = {}) {
+    return await this._collection.run(
       (collection) => {
-        return collection.countDocuments({ _id: id });
+        return collection.deleteMany(filter);
       },
       this._token,
       this._region
     );
-    return n > 0;
   }
   /**
-   * Returns the number of documents in the collection matching `filter`.
-   * Passing no filter (or an empty object) counts every document.
+   * Deletes the first document matching `filter` using a single `deleteOne` call.
    *
-   * @param filter - Optional query filter (default: `{}`)
-   * @returns Total number of matching documents
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @returns The raw `deleteOne` result document (e.g. `acknowledged`, `deletedCount`)
    */
-  async count(filter = {}) {
-    return this._collection.run(
+  async deleteOne(filter = {}) {
+    return await this._collection.run(
       (collection) => {
-        return collection.countDocuments(filter);
+        return collection.deleteOne(filter);
       },
       this._token,
       this._region
     );
   }
   /**
-   * Inserts or updates a document.
+   * Deletes the document with the given `_id` using a single `deleteOne` call.
    *
-   * - **Insert** (no `id`): stamps both `_created_at` and `_updated_at`, runs full schema
-   *   validation, then calls `insertOne`. Returns the new document's `_id`.
-   * - **Update** (with `id`): stamps `_updated_at`, runs **partial** validation (only columns
-   *   present in the payload are checked — required fields that are absent are not enforced
-   *   because they already exist in the stored document), then calls `updateOne` with
-   *   `upsert: true`. Returns the same `id` that was passed in.
+   * @param id - The `_id` of the document to delete (string or ObjectId)
+   * @returns The raw `deleteOne` result document (e.g. `acknowledged`, `deletedCount`)
+   */
+  async deleteById(id) {
+    return await this.deleteOne({ _id: new ObjectId(String(id)) });
+  }
+  /**
+   * Inserts multiple documents in a single `insertMany` call.
+   * Each payload is stamped with `_created_at` / `_updated_at` and validated
+   * against the full collection schema before the bulk write is sent to the DB.
    *
-   * @param payload - Document fields to write
-   * @param id - When provided, updates the document with this `_id`; otherwise inserts
-   * @returns The `_id` of the inserted or updated document
+   * @param payloads - Array of document payloads to insert
+   * @returns The raw `insertMany` result document (e.g. `acknowledged`, `insertedIds`)
    */
-  async save(payload = {}, id = "") {
+  async insert(payloads) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (id) {
-      const updatePayload = { ...payload, _updated_at: now };
-      this._validatePartial(updatePayload);
-      await this._collection.run(
-        async (collection) => {
-          await collection.updateOne({ _id: id }, updatePayload, { upsert: true });
-        },
-        this._token,
-        this._region
-      );
-      return id;
-    }
-    const insertPayload = { ...payload, _created_at: now, _updated_at: now };
-    this._collection.validate(insertPayload);
-    return this._collection.run(
-      async (collection) => {
-        return collection.insertOne(insertPayload);
+    const insertPayloads = payloads.map((payload) => {
+      const doc = { ...payload, _created_at: now, _updated_at: now };
+      this._collection.validate(doc);
+      return doc;
+    });
+    return await this._collection.run(
+      (collection) => {
+        return collection.insertMany(insertPayloads);
       },
       this._token,
       this._region
     );
   }
   /**
-   * Deletes the document with the given `_id`. No-ops silently when `id` is empty.
+   * Inserts a single document in a single `insertOne` call.
+   * The payload is stamped with `_created_at` / `_updated_at` and validated
+   * against the full collection schema before the write is sent to the DB.
    *
-   * @param id - The `_id` of the document to delete
+   * @param payload - Document payload to insert
+   * @returns The raw `insertOne` result document (e.g. `acknowledged`, `insertedId`)
    */
-  async delete(id = "") {
-    if (!id) return;
-    await this._collection.run(
-      async (collection) => {
-        await collection.deleteOne({ _id: id });
+  async insertOne(payload) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = { ...payload, _created_at: now, _updated_at: now };
+    this._collection.validate(doc);
+    return await this._collection.run(
+      (collection) => {
+        return collection.insertOne(doc);
       },
       this._token,
       this._region
     );
   }
   /**
-   * Inserts multiple documents in a single `insertMany` call.
-   * Each payload is stamped with `_created_at` / `_updated_at` and validated
+   * Updates multiple documents in a single `updateMany` call.
+   * Each payload is stamped with `_updated_at` and validated
    * against the full collection schema before the bulk write is sent to the DB.
    *
-   * @param payloads - Array of document payloads to insert
-   * @returns Array of inserted `_id` values in insertion order
+   * @param payload - Document fields to apply to every matched document
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @param options - Optional `updateMany` options (e.g. `{ upsert: true }`)
+   * @returns The raw `updateMany` result document (e.g. `acknowledged`, `modifiedCount`)
    */
-  async insertAll(payloads) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const insertPayloads = payloads.map((payload) => {
-      const doc = { ...payload, _created_at: now, _updated_at: now };
-      this._collection.validate(doc);
-      return doc;
-    });
-    return this._collection.run(
-      async (collection) => {
-        return collection.insertMany(insertPayloads);
+  async update(payload, filter = {}, options = {}) {
+    const updatePayload = {
+      ...payload,
+      _updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._validatePartial(updatePayload);
+    return await this._collection.run(
+      (collection) => {
+        return collection.updateMany(filter, { $set: updatePayload }, options);
       },
       this._token,
       this._region
     );
   }
   /**
-   * Applies a partial update to all documents matching `filter` using a single `updateMany` call.
-   * Stamps `_updated_at` on every matched document and runs partial validation on the payload
-   * (only the columns present in the payload are checked).
+   * Updates a single document in a single `updateOne` call.
+   * The payload is stamped with `_updated_at` and validated
+   * against the full collection schema before the write is sent to the DB.
    *
-   * @param payload - Fields to update on every matched document
-   * @param filter - Query condition selecting which documents to update (default: `{}` — all documents)
+   * @param payload - Document payload to update
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @param options - Optional `updateOne` options (e.g. `{ upsert: true }`)
+   * @returns The raw `updateOne` result document (e.g. `acknowledged`, `modifiedCount`)
    */
-  async updateAll(payload, filter = {}) {
-    const updatePayload = { ...payload, _updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  async updateOne(payload, filter = {}, options = {}) {
+    const updatePayload = {
+      ...payload,
+      _updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
     this._validatePartial(updatePayload);
-    await this._collection.run(
-      async (collection) => {
-        await collection.updateMany(filter, updatePayload);
+    return await this._collection.run(
+      (collection) => {
+        return collection.updateOne(filter, { $set: updatePayload }, options);
       },
       this._token,
       this._region
     );
   }
   /**
-   * Deletes all documents matching `filter` using a single `deleteMany` call.
-   * Passing no filter (or an empty object) deletes every document in the collection.
+   * Inserts or updates a document.
    *
-   * @param filter - Optional query filter (default: `{}`)
+   * @param payload - Document payload to insert or update
+   * @param id - The `_id` of the document to update (string or ObjectId)
+   * @returns The raw `insertOne` or `updateOne` result document (e.g. `acknowledged`, `insertedId`, `modifiedCount`)
    */
-  async deleteAll(filter = {}) {
-    await this._collection.run(
-      async (collection) => {
-        await collection.deleteMany(filter);
+  async save(payload = {}, id = "") {
+    if (id) {
+      return await this.updateOne(payload, { _id: new ObjectId(String(id)) }, { upsert: true });
+    }
+    return await this.insertOne(payload);
+  }
+  /**
+   * Returns `true` when a document with the given `_id` exists in the collection.
+   * Uses `countDocuments` rather than fetching the full document for efficiency.
+   *
+   * @param id - The `_id` to check
+   * @returns `true` if the document exists, `false` otherwise
+   */
+  async isIdExists(id) {
+    if (!id) return false;
+    return await this.exists({ _id: new ObjectId(String(id)) });
+  }
+  /**
+   * Returns `true` when a document matching `filter` exists in the collection.
+   * Uses `countDocuments` rather than fetching the full document for efficiency.
+   *
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @param options - Optional `countDocuments` options (e.g. `{ limit: 10 }`)
+   * @returns `true` if the document exists, `false` otherwise
+   */
+  async exists(filter = {}, options = {}) {
+    const n = await this.count(filter, options);
+    return n > 0;
+  }
+  /**
+   * Returns the number of documents in the collection matching `filter`.
+   * Passing no filter (or an empty object) counts every document.
+   *
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @param options - Optional `countDocuments` options (e.g. `{ limit: 10 }`)
+   * @returns The number of documents matching the filter
+   */
+  async count(filter = {}, options = {}) {
+    return await this._collection.run(
+      (collection) => {
+        return collection.countDocuments(filter, options);
       },
       this._token,
       this._region
@@ -2979,7 +6199,7 @@ var _AbdbRepository = class _AbdbRepository {
    * Required columns that are absent from the payload are intentionally skipped —
    * they already exist in the stored document and are not being changed.
    *
-   * Used by the update path of {@link save} and {@link updateAll}.
+   * Used by {@link update}, {@link updateOne}, and the update path of {@link save}.
    */
   _validatePartial(record) {
     for (const col of this._collection.getColumns()) {