ai-md-baileys 2.8.0 → 2.9.0

package/dist/cjs/lib/Defaults/index.js

@@ -0,0 +1,259 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  BIZ_BOT_SUPPORT_PAYLOAD: () => BIZ_BOT_SUPPORT_PAYLOAD,
+  BOT_RENDERING_CONFIG_METADATA: () => BOT_RENDERING_CONFIG_METADATA,
+  CALL_AUDIO_PREFIX: () => CALL_AUDIO_PREFIX,
+  CALL_VIDEO_PREFIX: () => CALL_VIDEO_PREFIX,
+  DEFAULT_CACHE_TTLS: () => DEFAULT_CACHE_TTLS,
+  DEFAULT_CONNECTION_CONFIG: () => DEFAULT_CONNECTION_CONFIG,
+  DEFAULT_ORIGIN: () => DEFAULT_ORIGIN,
+  DEF_CALLBACK_PREFIX: () => DEF_CALLBACK_PREFIX,
+  DEF_TAG_PREFIX: () => DEF_TAG_PREFIX,
+  DICT_VERSION: () => DICT_VERSION,
+  DONATE_URL: () => DONATE_URL,
+  HISTORY_SYNC_PAUSED_TIMEOUT_MS: () => HISTORY_SYNC_PAUSED_TIMEOUT_MS,
+  INITIAL_PREKEY_COUNT: () => INITIAL_PREKEY_COUNT,
+  KEY_BUNDLE_TYPE: () => KEY_BUNDLE_TYPE,
+  LEXER_REGEX: () => LEXER_REGEX,
+  LIBRARY_NAME: () => LIBRARY_NAME,
+  MEDIA_HKDF_KEY_MAPPING: () => MEDIA_HKDF_KEY_MAPPING,
+  MEDIA_KEYS: () => MEDIA_KEYS,
+  MEDIA_PATH_MAP: () => MEDIA_PATH_MAP,
+  MIN_PREKEY_COUNT: () => MIN_PREKEY_COUNT,
+  MIN_UPLOAD_INTERVAL: () => MIN_UPLOAD_INTERVAL,
+  NEWSLETTER_MEDIA_PATH_MAP: () => NEWSLETTER_MEDIA_PATH_MAP,
+  NOISE_MODE: () => NOISE_MODE,
+  NOISE_WA_HEADER: () => NOISE_WA_HEADER,
+  PHONE_CONNECTION_CB: () => PHONE_CONNECTION_CB,
+  PLACEHOLDER_MAX_AGE_SECONDS: () => PLACEHOLDER_MAX_AGE_SECONDS,
+  PROCESSABLE_HISTORY_TYPES: () => PROCESSABLE_HISTORY_TYPES,
+  STATUS_EXPIRY_SECONDS: () => STATUS_EXPIRY_SECONDS,
+  TimeMs: () => TimeMs,
+  UNAUTHORIZED_CODES: () => UNAUTHORIZED_CODES,
+  UPLOAD_TIMEOUT: () => UPLOAD_TIMEOUT,
+  URL_REGEX: () => URL_REGEX,
+  WA_ADV_ACCOUNT_SIG_PREFIX: () => WA_ADV_ACCOUNT_SIG_PREFIX,
+  WA_ADV_DEVICE_SIG_PREFIX: () => WA_ADV_DEVICE_SIG_PREFIX,
+  WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX: () => WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX,
+  WA_ADV_HOSTED_DEVICE_SIG_PREFIX: () => WA_ADV_HOSTED_DEVICE_SIG_PREFIX,
+  WA_CERT_DETAILS: () => WA_CERT_DETAILS,
+  WA_DEFAULT_EPHEMERAL: () => WA_DEFAULT_EPHEMERAL
+});
+module.exports = __toCommonJS(index_exports);
+var import_WAProto = require("../../WAProto/index.js");
+var import_libsignal = require("../Signal/libsignal.js");
+var import_browser_utils = require("../Utils/browser-utils.js");
+var import_logger = __toESM(require("../Utils/logger.js"));
+const version = [2, 3e3, 1038839325];
+const UNAUTHORIZED_CODES = [401, 403, 419];
+const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
+const DEFAULT_ORIGIN = "https://web.whatsapp.com";
+const CALL_VIDEO_PREFIX = "https://call.whatsapp.com/video/";
+const CALL_AUDIO_PREFIX = "https://call.whatsapp.com/voice/";
+const DONATE_URL = "https://saweria.co/itsliaaa";
+const LIBRARY_NAME = "itsliaaa/baileys";
+const DEF_CALLBACK_PREFIX = "CB:";
+const DEF_TAG_PREFIX = "TAG:";
+const PHONE_CONNECTION_CB = "CB:Pong";
+const WA_ADV_ACCOUNT_SIG_PREFIX = Buffer.from([6, 0]);
+const WA_ADV_DEVICE_SIG_PREFIX = Buffer.from([6, 1]);
+const WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX = Buffer.from([6, 5]);
+const WA_ADV_HOSTED_DEVICE_SIG_PREFIX = Buffer.from([6, 6]);
+const WA_DEFAULT_EPHEMERAL = 7 * 24 * 60 * 60;
+const STATUS_EXPIRY_SECONDS = 24 * 60 * 60;
+const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 24 * 60 * 60;
+const NOISE_MODE = "Noise_XX_25519_AESGCM_SHA256\0\0\0\0";
+const DICT_VERSION = 3;
+const KEY_BUNDLE_TYPE = Buffer.from([5]);
+const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]);
+const LEXER_REGEX = /(\/\/.*|\/\*[\s\S]*?\*\/|#.*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[\s\S]*?`)|(\b[a-zA-Z_]\w*\b)(?=\s*\()|(\b[a-zA-Z_]\w*\b)|(\b\d+(?:\.\d+)?\b)|(\s+|[^\w\s]+)/g;
+const URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
+const WA_CERT_DETAILS = {
+  SERIAL: 0,
+  ISSUER: "WhatsAppLongTerm1",
+  PUBLIC_KEY: Buffer.from("142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b", "hex")
+};
+const PROCESSABLE_HISTORY_TYPES = [
+  import_WAProto.proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
+  import_WAProto.proto.HistorySync.HistorySyncType.PUSH_NAME,
+  import_WAProto.proto.HistorySync.HistorySyncType.RECENT,
+  import_WAProto.proto.HistorySync.HistorySyncType.FULL,
+  import_WAProto.proto.HistorySync.HistorySyncType.ON_DEMAND,
+  import_WAProto.proto.HistorySync.HistorySyncType.NON_BLOCKING_DATA,
+  import_WAProto.proto.HistorySync.HistorySyncType.INITIAL_STATUS_V3
+];
+const DEFAULT_CONNECTION_CONFIG = {
+  version,
+  browser: import_browser_utils.Browsers.macOS("Chrome"),
+  waWebSocketUrl: "wss://web.whatsapp.com/ws/chat",
+  connectTimeoutMs: 2e4,
+  keepAliveIntervalMs: 15e3,
+  logger: import_logger.default.child({ class: "baileys" }),
+  emitOwnEvents: true,
+  defaultQueryTimeoutMs: 6e4,
+  customUploadHosts: [],
+  retryRequestDelayMs: 250,
+  maxMsgRetryCount: 3,
+  fireInitQueries: true,
+  auth: void 0,
+  markOnlineOnConnect: true,
+  syncFullHistory: true,
+  patchMessageBeforeSending: (msg) => msg,
+  shouldSyncHistoryMessage: ({ syncType }) => {
+    return syncType !== import_WAProto.proto.HistorySync.HistorySyncType.FULL;
+  },
+  shouldIgnoreJid: () => false,
+  linkPreviewImageThumbnailWidth: 192,
+  transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3e3 },
+  generateHighQualityLinkPreview: true,
+  enableAutoSessionRecreation: true,
+  enableRecentMessageCache: true,
+  options: {},
+  appStateMacVerification: {
+    patch: false,
+    snapshot: false
+  },
+  countryCode: "US",
+  getMessage: async () => void 0,
+  cachedGroupMetadata: async () => void 0,
+  makeSignalRepository: import_libsignal.makeLibSignalRepository
+};
+const MEDIA_PATH_MAP = {
+  image: "/mms/image",
+  video: "/mms/video",
+  document: "/mms/document",
+  audio: "/mms/audio",
+  sticker: "/mms/image",
+  "sticker-pack": "/mms/sticker-pack",
+  "thumbnail-sticker-pack": "/mms/thumbnail-sticker-pack",
+  "thumbnail-link": "/mms/image",
+  "product-catalog-image": "/product/image",
+  "md-app-state": "",
+  "md-msg-hist": "/mms/md-app-state",
+  "biz-cover-photo": "/pps/biz-cover-photo"
+};
+const NEWSLETTER_MEDIA_PATH_MAP = {
+  image: "/newsletter/newsletter-image",
+  video: "/newsletter/newsletter-video",
+  document: "/newsletter/newsletter-document",
+  audio: "/newsletter/newsletter-audio",
+  sticker: "/newsletter/newsletter-image",
+  "thumbnail-link": "/newsletter/newsletter-thumbnail-link"
+};
+const MEDIA_HKDF_KEY_MAPPING = {
+  audio: "Audio",
+  document: "Document",
+  gif: "Video",
+  image: "Image",
+  ppic: "",
+  product: "Image",
+  ptt: "Audio",
+  "sticker-pack": "Sticker Pack",
+  "thumbnail-sticker-pack": "Sticker Pack Thumbnail",
+  sticker: "Image",
+  video: "Video",
+  "thumbnail-document": "Document Thumbnail",
+  "thumbnail-image": "Image Thumbnail",
+  "thumbnail-video": "Video Thumbnail",
+  "thumbnail-link": "Link Thumbnail",
+  "md-msg-hist": "History",
+  "md-app-state": "App State",
+  "product-catalog-image": "",
+  "payment-bg-image": "Payment Background",
+  ptv: "Video",
+  "biz-cover-photo": "Image"
+};
+const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
+const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 12e4;
+const MIN_PREKEY_COUNT = 5;
+const INITIAL_PREKEY_COUNT = 812;
+const UPLOAD_TIMEOUT = 3e4;
+const MIN_UPLOAD_INTERVAL = 5e3;
+const DEFAULT_CACHE_TTLS = {
+  SIGNAL_STORE: 5 * 60,
+  // 5 minutes
+  MSG_RETRY: 60 * 60,
+  // 1 hour
+  CALL_OFFER: 5 * 60,
+  // 5 minutes
+  USER_DEVICES: 5 * 60
+  // 5 minutes
+};
+const TimeMs = {
+  Minute: 60 * 1e3,
+  Hour: 60 * 60 * 1e3,
+  Day: 24 * 60 * 60 * 1e3,
+  Week: 7 * 24 * 60 * 60 * 1e3
+};
+const BOT_RENDERING_CONFIG_METADATA = {
+  bloksVersioningId: "0903aa5f7f47de66789d5f4c86d3bd6e05e4bc3ff85e454a9f907d5ed7fef97c",
+  pixelDensity: 2.75
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BIZ_BOT_SUPPORT_PAYLOAD,
+  BOT_RENDERING_CONFIG_METADATA,
+  CALL_AUDIO_PREFIX,
+  CALL_VIDEO_PREFIX,
+  DEFAULT_CACHE_TTLS,
+  DEFAULT_CONNECTION_CONFIG,
+  DEFAULT_ORIGIN,
+  DEF_CALLBACK_PREFIX,
+  DEF_TAG_PREFIX,
+  DICT_VERSION,
+  DONATE_URL,
+  HISTORY_SYNC_PAUSED_TIMEOUT_MS,
+  INITIAL_PREKEY_COUNT,
+  KEY_BUNDLE_TYPE,
+  LEXER_REGEX,
+  LIBRARY_NAME,
+  MEDIA_HKDF_KEY_MAPPING,
+  MEDIA_KEYS,
+  MEDIA_PATH_MAP,
+  MIN_PREKEY_COUNT,
+  MIN_UPLOAD_INTERVAL,
+  NEWSLETTER_MEDIA_PATH_MAP,
+  NOISE_MODE,
+  NOISE_WA_HEADER,
+  PHONE_CONNECTION_CB,
+  PLACEHOLDER_MAX_AGE_SECONDS,
+  PROCESSABLE_HISTORY_TYPES,
+  STATUS_EXPIRY_SECONDS,
+  TimeMs,
+  UNAUTHORIZED_CODES,
+  UPLOAD_TIMEOUT,
+  URL_REGEX,
+  WA_ADV_ACCOUNT_SIG_PREFIX,
+  WA_ADV_DEVICE_SIG_PREFIX,
+  WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX,
+  WA_ADV_HOSTED_DEVICE_SIG_PREFIX,
+  WA_CERT_DETAILS,
+  WA_DEFAULT_EPHEMERAL
+});

package/dist/cjs/lib/Signal/Group/ciphertext-message.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ciphertext_message_exports = {};
+__export(ciphertext_message_exports, {
+  CiphertextMessage: () => CiphertextMessage
+});
+module.exports = __toCommonJS(ciphertext_message_exports);
+class CiphertextMessage {
+  constructor() {
+    this.UNSUPPORTED_VERSION = 1;
+    this.CURRENT_VERSION = 3;
+    this.WHISPER_TYPE = 2;
+    this.PREKEY_TYPE = 3;
+    this.SENDERKEY_TYPE = 4;
+    this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+    this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CiphertextMessage
+});

package/dist/cjs/lib/Signal/Group/group-session-builder.js

@@ -0,0 +1,65 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var group_session_builder_exports = {};
+__export(group_session_builder_exports, {
+  GroupSessionBuilder: () => GroupSessionBuilder
+});
+module.exports = __toCommonJS(group_session_builder_exports);
+var keyhelper = __toESM(require("./keyhelper.js"));
+var import_sender_key_distribution_message = require("./sender-key-distribution-message.js");
+var import_sender_key_name = require("./sender-key-name.js");
+var import_sender_key_record = require("./sender-key-record.js");
+class GroupSessionBuilder {
+  constructor(senderKeyStore) {
+    this.senderKeyStore = senderKeyStore;
+  }
+  async process(senderKeyName, senderKeyDistributionMessage) {
+    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+    senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+    await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+  }
+  async create(senderKeyName) {
+    const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+    if (senderKeyRecord.isEmpty()) {
+      const keyId = keyhelper.generateSenderKeyId();
+      const senderKey = keyhelper.generateSenderKey();
+      const signingKey = keyhelper.generateSenderSigningKey();
+      senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+      await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    const state = senderKeyRecord.getSenderKeyState();
+    if (!state) {
+      throw new Error("No session state available");
+    }
+    return new import_sender_key_distribution_message.SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GroupSessionBuilder
+});

package/dist/cjs/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var group_cipher_exports = {};
+__export(group_cipher_exports, {
+  GroupCipher: () => GroupCipher
+});
+module.exports = __toCommonJS(group_cipher_exports);
+var import_crypto = require("libsignal/src/crypto.js");
+var import_sender_key_message = require("./sender-key-message.js");
+var import_sender_key_name = require("./sender-key-name.js");
+var import_sender_key_record = require("./sender-key-record.js");
+var import_sender_key_state = require("./sender-key-state.js");
+class GroupCipher {
+  constructor(senderKeyStore, senderKeyName) {
+    this.senderKeyStore = senderKeyStore;
+    this.senderKeyName = senderKeyName;
+  }
+  async encrypt(paddedPlaintext) {
+    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+    if (!record) {
+      throw new Error("No SenderKeyRecord found for encryption");
+    }
+    const senderKeyState = record.getSenderKeyState();
+    if (!senderKeyState) {
+      throw new Error("No session to encrypt message");
+    }
+    const iteration = senderKeyState.getSenderChainKey().getIteration();
+    const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+    const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+    const senderKeyMessage = new import_sender_key_message.SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+    await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+    return senderKeyMessage.serialize();
+  }
+  async decrypt(senderKeyMessageBytes) {
+    const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+    if (!record) {
+      throw new Error("No SenderKeyRecord found for decryption");
+    }
+    const senderKeyMessage = new import_sender_key_message.SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+    const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+    if (!senderKeyState) {
+      throw new Error("No session found to decrypt message");
+    }
+    senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+    const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+    const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+    await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+    return plaintext;
+  }
+  getSenderKey(senderKeyState, iteration) {
+    let senderChainKey = senderKeyState.getSenderChainKey();
+    if (senderChainKey.getIteration() > iteration) {
+      if (senderKeyState.hasSenderMessageKey(iteration)) {
+        const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+        if (!messageKey) {
+          throw new Error("No sender message key found for iteration");
+        }
+        return messageKey;
+      }
+      throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+    }
+    if (iteration - senderChainKey.getIteration() > 2e3) {
+      throw new Error("Over 2000 messages into the future!");
+    }
+    while (senderChainKey.getIteration() < iteration) {
+      senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+      senderChainKey = senderChainKey.getNext();
+    }
+    senderKeyState.setSenderChainKey(senderChainKey.getNext());
+    return senderChainKey.getSenderMessageKey();
+  }
+  async getPlainText(iv, key, ciphertext) {
+    try {
+      return (0, import_crypto.decrypt)(key, ciphertext, iv);
+    } catch (e) {
+      throw new Error("InvalidMessageException");
+    }
+  }
+  async getCipherText(iv, key, plaintext) {
+    try {
+      return (0, import_crypto.encrypt)(key, plaintext, iv);
+    } catch (e) {
+      throw new Error("InvalidMessageException");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GroupCipher
+});

package/dist/cjs/lib/Signal/Group/index.js

@@ -0,0 +1,67 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  CiphertextMessage: () => import_ciphertext_message.CiphertextMessage,
+  GroupCipher: () => import_group_cipher.GroupCipher,
+  GroupSessionBuilder: () => import_group_session_builder.GroupSessionBuilder,
+  SenderChainKey: () => import_sender_chain_key.SenderChainKey,
+  SenderKeyDistributionMessage: () => import_sender_key_distribution_message.SenderKeyDistributionMessage,
+  SenderKeyMessage: () => import_sender_key_message.SenderKeyMessage,
+  SenderKeyName: () => import_sender_key_name.SenderKeyName,
+  SenderKeyRecord: () => import_sender_key_record.SenderKeyRecord,
+  SenderKeyState: () => import_sender_key_state.SenderKeyState,
+  SenderMessageKey: () => import_sender_message_key.SenderMessageKey,
+  keyhelper: () => keyhelper
+});
+module.exports = __toCommonJS(index_exports);
+var import_group_session_builder = require("./group-session-builder.js");
+var import_sender_key_distribution_message = require("./sender-key-distribution-message.js");
+var import_sender_key_record = require("./sender-key-record.js");
+var import_sender_key_name = require("./sender-key-name.js");
+var import_group_cipher = require("./group_cipher.js");
+var import_sender_key_state = require("./sender-key-state.js");
+var import_sender_key_message = require("./sender-key-message.js");
+var import_sender_message_key = require("./sender-message-key.js");
+var import_sender_chain_key = require("./sender-chain-key.js");
+var import_ciphertext_message = require("./ciphertext-message.js");
+var keyhelper = __toESM(require("./keyhelper.js"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CiphertextMessage,
+  GroupCipher,
+  GroupSessionBuilder,
+  SenderChainKey,
+  SenderKeyDistributionMessage,
+  SenderKeyMessage,
+  SenderKeyName,
+  SenderKeyRecord,
+  SenderKeyState,
+  SenderMessageKey,
+  keyhelper
+});

package/dist/cjs/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,57 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var keyhelper_exports = {};
+__export(keyhelper_exports, {
+  generateSenderKey: () => generateSenderKey,
+  generateSenderKeyId: () => generateSenderKeyId,
+  generateSenderSigningKey: () => generateSenderSigningKey
+});
+module.exports = __toCommonJS(keyhelper_exports);
+var nodeCrypto = __toESM(require("crypto"));
+var import_curve = require("libsignal/src/curve.js");
+function generateSenderKey() {
+  return nodeCrypto.randomBytes(32);
+}
+function generateSenderKeyId() {
+  return nodeCrypto.randomInt(2147483647);
+}
+function generateSenderSigningKey(key) {
+  if (!key) {
+    key = (0, import_curve.generateKeyPair)();
+  }
+  return {
+    public: Buffer.from(key.pubKey),
+    private: Buffer.from(key.privKey)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateSenderKey,
+  generateSenderKeyId,
+  generateSenderSigningKey
+});

package/dist/cjs/lib/Signal/Group/queue-job.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queueJob;
+const _queueAsyncBuckets = /* @__PURE__ */ new Map();
+const _gcLimit = 1e4;
+async function _asyncQueueExecutor(queue, cleanup) {
+  let offt = 0;
+  while (true) {
+    const limit = Math.min(queue.length, _gcLimit);
+    for (let i = offt; i < limit; i++) {
+      const job = queue[i];
+      try {
+        job.resolve(await job.awaitable());
+      } catch (e) {
+        job.reject(e);
+      }
+    }
+    if (limit < queue.length) {
+      if (limit >= _gcLimit) {
+        queue.splice(0, limit);
+        offt = 0;
+      } else {
+        offt = limit;
+      }
+    } else {
+      break;
+    }
+  }
+  cleanup();
+}
+function queueJob(bucket, awaitable) {
+  if (typeof bucket !== "string") {
+    console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
+  }
+  let inactive = false;
+  if (!_queueAsyncBuckets.has(bucket)) {
+    _queueAsyncBuckets.set(bucket, []);
+    inactive = true;
+  }
+  const queue = _queueAsyncBuckets.get(bucket);
+  const job = new Promise((resolve, reject) => {
+    queue.push({
+      awaitable,
+      resolve,
+      reject
+    });
+  });
+  if (inactive) {
+    _asyncQueueExecutor(queue, () => _queueAsyncBuckets.delete(bucket));
+  }
+  return job;
+}