@mrlegendbot/baileys 1.2.5 → 1.2.7

package/lib/Utils/history.d.ts

@@ -0,0 +1,24 @@
+import { proto } from '../../WAProto/index.js';
+import type { Chat, Contact, LIDMapping, WAMessage } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+export declare const downloadHistory: (msg: proto.Message.IHistorySyncNotification, options: RequestInit) => Promise<proto.HistorySync>;
+export declare const processHistoryMessage: (item: proto.IHistorySync, logger?: ILogger) => {
+    chats: Chat[];
+    contacts: Contact[];
+    messages: WAMessage[];
+    lidPnMappings: LIDMapping[];
+    pastParticipants: proto.IPastParticipants[] | null | undefined;
+    syncType: proto.HistorySync.HistorySyncType | null | undefined;
+    progress: number | null | undefined;
+};
+export declare const downloadAndProcessHistorySyncNotification: (msg: proto.Message.IHistorySyncNotification, options: RequestInit, logger?: ILogger) => Promise<{
+    chats: Chat[];
+    contacts: Contact[];
+    messages: WAMessage[];
+    lidPnMappings: LIDMapping[];
+    pastParticipants: proto.IPastParticipants[] | null | undefined;
+    syncType: proto.HistorySync.HistorySyncType | null | undefined;
+    progress: number | null | undefined;
+}>;
+export declare const getHistoryMsg: (message: proto.IMessage) => proto.Message.IHistorySyncNotification;
+//# sourceMappingURL=history.d.ts.map

package/lib/Utils/history.js

@@ -1,142 +1,134 @@
 import { pipeline } from 'stream/promises';
 import { promisify } from 'util';
 import { createInflate, inflate } from 'zlib';
-import { proto } from '../../WAProto/compiler.js';
+import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
 import { toNumber } from './generics.js';
 import { normalizeMessageContent } from './messages.js';
 import { downloadContentFromMessage } from './messages-media.js';
 const inflatePromise = promisify(inflate);
-const extractPnFromMessages = messages => {
-  for (const msgItem of messages) {
-    const message = msgItem.message;
-    if (!message?.key?.fromMe || !message.userReceipt?.length) {
-      continue;
-    }
-    const userJid = message.userReceipt[0]?.userJid;
-    if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
-      return userJid;
+const extractPnFromMessages = (messages) => {
+    for (const msgItem of messages) {
+        const message = msgItem.message;
+        // Only extract from outgoing messages (fromMe: true) in 1:1 chats
+        // because userReceipt.userJid is the recipient's JID
+        if (!message?.key?.fromMe || !message.userReceipt?.length) {
+            continue;
+        }
+        const userJid = message.userReceipt[0]?.userJid;
+        if (userJid && (isPnUser(userJid) || isHostedPnUser(userJid))) {
+            return userJid;
+        }
     }
-  }
-  return undefined;
+    return undefined;
 };
 export const downloadHistory = async (msg, options) => {
-  const stream = await downloadContentFromMessage(msg, 'md-msg-hist', {
-    options
-  });
-  const inflater = createInflate();
-  const chunks = [];
-  inflater.on('data', chunk => chunks.push(chunk));
-  await pipeline(stream, inflater);
-  const buffer = Buffer.concat(chunks);
-  const syncData = proto.HistorySync.decode(buffer);
-  return syncData;
+    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
+    // Pipe decrypted stream directly through zlib inflate
+    // This avoids allocating an intermediate buffer for the compressed data
+    const inflater = createInflate();
+    const chunks = [];
+    inflater.on('data', (chunk) => chunks.push(chunk));
+    await pipeline(stream, inflater);
+    const buffer = Buffer.concat(chunks);
+    const syncData = proto.HistorySync.decode(buffer);
+    return syncData;
 };
 export const processHistoryMessage = (item, logger) => {
-  const messages = [];
-  const contacts = [];
-  const chats = [];
-  const lidPnMappings = [];
-  logger?.trace({
-    progress: item.progress
-  }, 'processing history of type ' + item.syncType?.toString());
-  for (const m of item.phoneNumberToLidMappings || []) {
-    if (m.lidJid && m.pnJid) {
-      lidPnMappings.push({
-        lid: m.lidJid,
-        pn: m.pnJid
-      });
-    }
-  }
-  switch (item.syncType) {
-    case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
-    case proto.HistorySync.HistorySyncType.RECENT:
-    case proto.HistorySync.HistorySyncType.FULL:
-    case proto.HistorySync.HistorySyncType.ON_DEMAND:
-      for (const chat of item.conversations) {
-        contacts.push({
-          id: chat.id,
-          name: chat.displayName || chat.name || chat.username || undefined,
-          username: chat.username || undefined,
-          lid: chat.lidJid || chat.accountLid || undefined,
-          phoneNumber: chat.pnJid || undefined
-        });
-        const chatId = chat.id;
-        const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
-        const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
-        if (isLid && chat.pnJid) {
-          lidPnMappings.push({
-            lid: chatId,
-            pn: chat.pnJid
-          });
-        } else if (isPn && chat.lidJid) {
-          lidPnMappings.push({
-            lid: chat.lidJid,
-            pn: chatId
-          });
-        } else if (isLid && !chat.pnJid) {
-          const pnFromReceipt = extractPnFromMessages(chat.messages || []);
-          if (pnFromReceipt) {
-            lidPnMappings.push({
-              lid: chatId,
-              pn: pnFromReceipt
-            });
-          }
-        }
-        const msgs = chat.messages || [];
-        delete chat.messages;
-        for (const item of msgs) {
-          const message = item.message;
-          messages.push(message);
-          if (!chat.messages?.length) {
-            chat.messages = [{
-              message
-            }];
-          }
-          if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
-            chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
-          }
-          if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP || message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) && message.messageStubParameters?.[0]) {
-            contacts.push({
-              id: message.key.participant || message.key.remoteJid,
-              verifiedName: message.messageStubParameters?.[0]
-            });
-          }
+    const messages = [];
+    const contacts = [];
+    const chats = [];
+    const lidPnMappings = [];
+    logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
+    // Extract LID-PN mappings for all sync types
+    for (const m of item.phoneNumberToLidMappings || []) {
+        if (m.lidJid && m.pnJid) {
+            lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
         }
-        chats.push(chat);
-      }
-      break;
-    case proto.HistorySync.HistorySyncType.PUSH_NAME:
-      for (const c of item.pushnames) {
-        contacts.push({
-          id: c.id,
-          notify: c.pushname
-        });
-      }
-      break;
-  }
-  return {
-    chats,
-    contacts,
-    messages,
-    lidPnMappings,
-    pastParticipants: item.pastParticipants,
-    syncType: item.syncType,
-    progress: item.progress
-  };
+    }
+    switch (item.syncType) {
+        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case proto.HistorySync.HistorySyncType.RECENT:
+        case proto.HistorySync.HistorySyncType.FULL:
+        case proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
+                contacts.push({
+                    id: chat.id,
+                    name: chat.displayName || chat.name || chat.username || undefined,
+                    username: chat.username || undefined,
+                    lid: chat.lidJid || chat.accountLid || undefined,
+                    phoneNumber: chat.pnJid || undefined
+                });
+                const chatId = chat.id;
+                const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
+                const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
+                if (isLid && chat.pnJid) {
+                    lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
+                }
+                else if (isPn && chat.lidJid) {
+                    lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
+                }
+                else if (isLid && !chat.pnJid) {
+                    // Fallback: extract PN from userReceipt in messages when pnJid is missing
+                    const pnFromReceipt = extractPnFromMessages(chat.messages || []);
+                    if (pnFromReceipt) {
+                        lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
+                    }
+                }
+                const msgs = chat.messages || [];
+                delete chat.messages;
+                for (const item of msgs) {
+                    const message = item.message;
+                    messages.push(message);
+                    if (!chat.messages?.length) {
+                        // keep only the most recent message in the chat array
+                        chat.messages = [{ message }];
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+                    }
+                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+                        message.messageStubParameters?.[0]) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0]
+                        });
+                    }
+                }
+                chats.push(chat);
+            }
+            break;
+        case proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ id: c.id, notify: c.pushname });
+            }
+            break;
+    }
+    return {
+        chats,
+        contacts,
+        messages,
+        lidPnMappings,
+        pastParticipants: item.pastParticipants,
+        syncType: item.syncType,
+        progress: item.progress
+    };
 };
 export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
-  let historyMsg;
-  if (msg.initialHistBootstrapInlinePayload) {
-    historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
-  } else {
-    historyMsg = await downloadHistory(msg, options);
-  }
-  return processHistoryMessage(historyMsg, logger);
+    let historyMsg;
+    if (msg.initialHistBootstrapInlinePayload) {
+        historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
+    }
+    else {
+        historyMsg = await downloadHistory(msg, options);
+    }
+    return processHistoryMessage(historyMsg, logger);
 };
-export const getHistoryMsg = message => {
-  const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
-  const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
-  return anyHistoryMsg;
+export const getHistoryMsg = (message) => {
+    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
+    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+    return anyHistoryMsg;
 };
+//# sourceMappingURL=history.js.map

package/lib/Utils/identity-change-handler.d.ts

@@ -0,0 +1,44 @@
+import NodeCache from '@cacheable/node-cache';
+import { type BinaryNode } from '../WABinary/index.js';
+import type { ILogger } from './logger.js';
+export type IdentityChangeResult = {
+    action: 'no_identity_node';
+} | {
+    action: 'invalid_notification';
+} | {
+    action: 'skipped_companion_device';
+    device: number;
+} | {
+    action: 'skipped_self_primary';
+} | {
+    action: 'debounced';
+} | {
+    action: 'skipped_offline';
+} | {
+    action: 'skipped_no_session';
+} | {
+    action: 'session_refreshed';
+} | {
+    action: 'session_refresh_failed';
+    error: unknown;
+};
+export type IdentityChangeContext = {
+    meId: string | undefined;
+    meLid: string | undefined;
+    validateSession: (jid: string) => Promise<{
+        exists: boolean;
+        reason?: string;
+    }>;
+    assertSessions: (jids: string[], force?: boolean) => Promise<boolean>;
+    debounceCache: NodeCache<boolean>;
+    logger: ILogger;
+    /**
+     * Invoked right before `assertSessions` is called for an existing-session identity change.
+     * Used to kick off fire-and-forget side effects (e.g. tctoken re-issuance) in the same
+     * order WA Web does — i.e. before the E2E session is re-established.
+     * Must not throw; implementations are responsible for their own error handling.
+     */
+    onBeforeSessionRefresh?: (jid: string) => void;
+};
+export declare function handleIdentityChange(node: BinaryNode, ctx: IdentityChangeContext): Promise<IdentityChangeResult>;
+//# sourceMappingURL=identity-change-handler.d.ts.map

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,50 @@
+import NodeCache from '@cacheable/node-cache';
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
+import { isStringNullOrEmpty } from './generics.js';
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = getBinaryNodeChild(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = jidDecode(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    ctx.onBeforeSessionRefresh?.(from);
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}
+//# sourceMappingURL=identity-change-handler.js.map

package/lib/Utils/index.d.ts

@@ -0,0 +1,22 @@
+export * from './generics.js';
+export * from './decode-wa-message.js';
+export * from './messages.js';
+export * from './messages-media.js';
+export * from './validate-connection.js';
+export * from './crypto.js';
+export * from './signal.js';
+export * from './noise-handler.js';
+export * from './history.js';
+export * from './chat-utils.js';
+export * from './lt-hash.js';
+export * from './auth-utils.js';
+export * from './use-multi-file-auth-state.js';
+export * from './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.js';
+export * from './message-retry-manager.js';
+export * from './browser-utils.js';
+export * from './companion-reg-client-utils.js';
+export * from './identity-change-handler.js';
+export * from './stanza-ack.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/Utils/index.js

@@ -17,5 +17,6 @@ export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
+export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
-export * from './use-sqlite-auth-state.js';
+//# sourceMappingURL=index.js.map

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,21 @@
+import type { WAMediaUploadFunction, WAUrlInfo } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: HeadersInit;
+    };
+    uploadImage?: WAMediaUploadFunction;
+    logger?: ILogger;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>;
+//# sourceMappingURL=link-preview.d.ts.map

package/lib/Utils/link-preview.js

@@ -1,86 +1,85 @@
 import { prepareWAMessageMedia } from './messages.js';
 import { extractImageThumb, getHttpStream } from './messages-media.js';
 const THUMBNAIL_WIDTH_PX = 192;
-const getCompressedJpegThumbnail = async (url, {
-  thumbnailWidth,
-  fetchOpts
-}) => {
-  const stream = await getHttpStream(url, fetchOpts);
-  const result = await extractImageThumb(stream, thumbnailWidth);
-  return result;
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
 };
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
 export const getUrlInfo = async (text, opts = {
-  thumbnailWidth: THUMBNAIL_WIDTH_PX,
-  fetchOpts: {
-    timeout: 3000
-  }
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
 }) => {
-  try {
-    let retries = 0;
-    const maxRetry = 5;
-    const {
-      getLinkPreview
-    } = await import('link-preview-js');
-    let previewLink = text;
-    if (!text.startsWith('https://') && !text.startsWith('http://')) {
-      previewLink = 'https://' + previewLink;
-    }
-    const info = await getLinkPreview(previewLink, {
-      ...opts.fetchOpts,
-      followRedirects: 'follow',
-      handleRedirects: (baseURL, forwardedURL) => {
-        const urlObj = new URL(baseURL);
-        const forwardedURLObj = new URL(forwardedURL);
-        if (retries >= maxRetry) {
-          return false;
+    try {
+        // retries
+        let retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
         }
-        if (forwardedURLObj.hostname === urlObj.hostname || forwardedURLObj.hostname === 'www.' + urlObj.hostname || 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
-          retries += 1;
-          return true;
-        } else {
-          return false;
-        }
-      },
-      headers: opts.fetchOpts?.headers
-    });
-    if (info && 'title' in info && info.title) {
-      const [image] = info.images;
-      const urlInfo = {
-        'canonical-url': info.url,
-        'matched-text': text,
-        title: info.title,
-        description: info.description,
-        originalThumbnailUrl: image
-      };
-      if (opts.uploadImage) {
-        const {
-          imageMessage
-        } = await prepareWAMessageMedia({
-          image: {
-            url: image
-          }
-        }, {
-          upload: opts.uploadImage,
-          mediaTypeOverride: 'thumbnail-link',
-          options: opts.fetchOpts
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries += 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts?.headers
         });
-        urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
-        urlInfo.highQualityThumbnail = imageMessage || undefined;
-      } else {
-        try {
-          urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
-        } catch (error) {
-          opts.logger?.debug({
-            err: error.stack,
-            url: previewLink
-          }, 'error in generating thumbnail');
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images;
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
         }
-      }
-      return urlInfo;
     }
-  } catch (error) {
-    if (!error.message.includes('receive a valid')) {
-      throw error;
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
     }
-  }
 };
+//# sourceMappingURL=link-preview.js.map

package/lib/Utils/logger.d.ts

@@ -0,0 +1,12 @@
+export interface ILogger {
+    level: string;
+    child(obj: Record<string, unknown>): ILogger;
+    trace(obj: unknown, msg?: string): void;
+    debug(obj: unknown, msg?: string): void;
+    info(obj: unknown, msg?: string): void;
+    warn(obj: unknown, msg?: string): void;
+    error(obj: unknown, msg?: string): void;
+}
+declare const _default: import("pino").Logger<never, boolean>;
+export default _default;
+//# sourceMappingURL=logger.d.ts.map

package/lib/Utils/logger.js

@@ -1,4 +1,3 @@
 import P from 'pino';
-export default P({
-  timestamp: () => `,"time":"${new Date().toJSON()}"`
-});
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+//# sourceMappingURL=logger.js.map

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,8 @@
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+export declare const LT_HASH_ANTI_TAMPERING: LTHashAntiTampering;
+//# sourceMappingURL=lt-hash.d.ts.map

package/lib/Utils/lt-hash.js

@@ -1,2 +1,8 @@
 import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
 export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+//# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,9 @@
+export declare const makeMutex: () => {
+    mutex<T>(code: () => Promise<T> | T): Promise<T>;
+};
+export type Mutex = ReturnType<typeof makeMutex>;
+export declare const makeKeyedMutex: () => {
+    mutex<T>(key: string, task: () => Promise<T> | T): Promise<T>;
+};
+export type KeyedMutex = ReturnType<typeof makeKeyedMutex>;
+//# sourceMappingURL=make-mutex.d.ts.map