sauruspro-bail 0.0.0-stage → 5.0.1

package/lib/Utils/html-app.js

@@ -0,0 +1,291 @@
+import { airichRegistry as _MBModule } from './airich-registry.js';
+import * as crypto from 'crypto';
+let _AIRich;
+function getAIRich() {
+    if (!_AIRich) {
+        _AIRich = _MBModule.AIRich;
+    }
+    return _AIRich;
+}
+
+const HTML_APP_MESSAGE_CEILING = 1024 * 1024;
+
+const HTML_APP_BYTE_BUDGET = 960 * 1024;
+
+const HTML_APP_BYTE_LIMIT = HTML_APP_BYTE_BUDGET;
+
+const HTML_MIME_TYPE = 'text/html';
+
+const wireBytes = (html) => Buffer.byteLength(
+    JSON.stringify(String(html)).replace(/[\u007f-\uffff]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0')),
+    'utf-8'
+);
+
+const STORAGE_APIS = ['localStorage', 'sessionStorage', 'indexedDB', 'document.cookie', 'caches'];
+
+const strip = (html) => html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/data:[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]*;base64,[A-Za-z0-9+/=]+/gi, 'data:');
+
+const hasVisibilityGuard = (source) => /document\.(hidden|visibilityState)|visibilitychange|IntersectionObserver|cancelAnimationFrame|clearInterval/.test(source);
+
+const checkHtmlApp = (html, { height, maxBytes = HTML_APP_BYTE_BUDGET } = {}) => {
+    if (typeof html !== 'string') {
+        throw new TypeError('checkHtmlApp requires an HTML string');
+    }
+
+    const bytes = Buffer.byteLength(html, 'utf-8');
+    const wire = wireBytes(html);
+    const source = strip(html);
+    const problems = [];
+    const warnings = [];
+
+    if (wire > maxBytes) {
+        problems.push(`${Math.round(wire / 1024)}KB on the wire, over the ${Math.round(maxBytes / 1024)}KB budget`);
+    }
+
+    if (wire > bytes * 1.15) {
+        warnings.push(`escaping inflates this page from ${Math.round(bytes / 1024)}KB to ${Math.round(wire / 1024)}KB`);
+    }
+
+    const remote = [...source.matchAll(/\b(?:src|href)\s*=\s*["']?(https?:)?\/\//gi)];
+    if (remote.length) {
+        problems.push(`${remote.length} remote subresource(s) — embed as data: URIs instead`);
+    }
+
+    if (/\bfetch\s*\(|XMLHttpRequest|navigator\.sendBeacon|new\s+EventSource/.test(source)) {
+        problems.push('a call over HTTP stack — use offline/embedded storage');
+    }
+
+    const storage = STORAGE_APIS.filter(api => source.includes(api));
+    if (storage.length) {
+        problems.push(`${storage.join(', ')} — every storage API throws SecurityError in an opaque origin`);
+    }
+
+    return { ok: problems.length === 0, bytes, wireBytes: wire, problems, warnings };
+};
+
+const lockHeight = (height) => {
+    const px = Number(height);
+    if (!Number.isFinite(px) || px <= 0) {
+        throw new TypeError('lockHeight requires a positive number of pixels');
+    }
+    return '<style>html,body{height:' + Math.round(px) + 'px;max-height:' + Math.round(px) + 'px;overflow:hidden}</style>';
+};
+
+const autoHeight = ({ min = 60, max = 900, settleMs = 120, maxReports = 24 } = {}) => {
+    const low = Number(min);
+    const high = Number(max);
+    const wait = Number(settleMs);
+    const cap = Number(maxReports);
+    if (!Number.isFinite(low) || low <= 0) {
+        throw new TypeError('autoHeight min must be a positive number of pixels');
+    }
+    if (!Number.isFinite(high) || high <= low) {
+        throw new TypeError('autoHeight max must be greater than min');
+    }
+    return '<style>html,body{margin:0;padding:0}</style>'
+        + '<script>(function(){'
+        + 'var LOW=' + low + ',HIGH=' + high + ',WAIT=' + wait + ',CAP=' + cap + ';'
+        + 'var sent=[],timer=null,stopped=false;'
+        + 'function measure(){var d=document.documentElement,b=document.body;'
+        + 'var h=Math.max(d?d.scrollHeight:0,b?b.scrollHeight:0,b?b.offsetHeight:0);'
+        + 'return Math.min(HIGH,Math.max(LOW,Math.ceil(h)))}'
+        + 'function report(){if(stopped)return;var h=measure();'
+        + 'if(sent.length&&sent[sent.length-1]===h)return;'
+        + 'sent.push(h);if(sent.length>=CAP)stopped=true;'
+        + 'if(window.AndroidBridge&&typeof window.AndroidBridge.updateSize==="function"){'
+        + 'try{window.AndroidBridge.updateSize(h)}catch(e){}}}'
+        + 'function ping(){if(timer!==null)clearTimeout(timer);timer=setTimeout(report,WAIT)}'
+        + 'if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",ping);else ping();'
+        + 'window.addEventListener("load",ping);'
+        + 'if(typeof ResizeObserver==="function"){try{new ResizeObserver(ping).observe(document.body)}catch(e){}}'
+        + '})();<' + '/script>';
+};
+
+const scrollControls = ({ step = 120, holdMs = 60, target = 'body', side = 'right', inset = 8, size = 36 } = {}) => {
+    const px = Number(step);
+    const hold = Number(holdMs);
+    const box = Number(size);
+    const edge = Number(inset);
+    return '<style>'
+        + '#__sc{position:fixed;' + side + ':' + edge + 'px;bottom:' + edge + 'px;z-index:2147483647;'
+        + 'display:none;flex-direction:column;gap:' + Math.round(box / 6) + 'px}'
+        + '#__sc button{width:' + box + 'px;height:' + box + 'px;padding:0;border:0;'
+        + 'border-radius:' + Math.round(box / 4) + 'px;background:rgba(0,0,0,.6);color:#fff;'
+        + 'font:' + Math.round(box / 2) + 'px/1 system-ui;touch-action:none;cursor:pointer;'
+        + '-webkit-tap-highlight-color:transparent}'
+        + '#__sc button:disabled{opacity:.3}'
+        + '</style>'
+        + '<script>(function(){'
+        + 'var STEP=' + px + ',HOLD=' + hold + ',SEL=' + JSON.stringify(target) + ';'
+        + 'var box,up,down,timer=null;'
+        + 'function pane(){return document.querySelector(SEL)||document.scrollingElement||document.body}'
+        + 'function room(){var p=pane();return p?p.scrollHeight-p.clientHeight:0}'
+        + 'function sync(){if(!box)return;var p=pane(),r=room();'
+        + 'box.style.display=r>4?"flex":"none";if(r<=4)return;'
+        + 'up.disabled=p.scrollTop<=0;down.disabled=p.scrollTop>=r-1}'
+        + 'function move(by){var p=pane();if(!p)return;p.scrollTop+=by;sync()}'
+        + 'function stop(){if(timer!==null){clearInterval(timer);timer=null}}'
+        + 'function press(e,by){e.preventDefault();e.stopPropagation();stop();move(by);'
+        + 'timer=setInterval(function(){move(by)},HOLD)}'
+        + 'function make(label,by){var b=document.createElement("button");b.type="button";'
+        + 'b.textContent=label;b.setAttribute("aria-label",by<0?"scroll up":"scroll down");'
+        + 'b.addEventListener("touchstart",function(e){press(e,by)},{passive:false});'
+        + 'b.addEventListener("touchend",function(e){e.preventDefault();stop()},{passive:false});'
+        + 'b.addEventListener("touchcancel",stop);'
+        + 'b.addEventListener("mousedown",function(e){press(e,by)});'
+        + 'b.addEventListener("mouseup",stop);b.addEventListener("mouseleave",stop);'
+        + 'b.addEventListener("click",function(e){e.preventDefault();e.stopPropagation()});'
+        + 'return b}'
+        + 'function start(){if(box)return;'
+        + 'box=document.createElement("div");box.id="__sc";'
+        + 'up=make("\\u25b2",-STEP);down=make("\\u25bc",STEP);'
+        + 'box.appendChild(up);box.appendChild(down);document.body.appendChild(box);'
+        + 'var p=pane();if(p&&p.addEventListener)p.addEventListener("scroll",sync,{passive:true});'
+        + 'if(typeof ResizeObserver==="function"){try{new ResizeObserver(sync).observe(document.body)}catch(e){}}'
+        + 'addEventListener("load",sync);sync()}'
+        + 'if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",start);else start();'
+        + 'window.__scrollControls={by:move,sync:sync};'
+        + '})();<' + '/script>';
+};
+
+const AI_RICH_HTML_PRIMITIVE = 'GenAIaeacdsnwHtmlPrimitive';
+
+const htmlSection = (html, { trustedSources = [], height, typename = AI_RICH_HTML_PRIMITIVE } = {}) => {
+    if (typeof html !== 'string' || html.trim() === '') {
+        throw new TypeError('htmlSection requires a non-empty HTML string');
+    }
+    return getAIRich().newLayout('Single', {
+        payload: height === undefined ? html : lockHeight(height) + html,
+        trusted_sources: Array.isArray(trustedSources) ? trustedSources.map(String) : [],
+        __typename: typename
+    });
+};
+
+/**
+ * sendHtmlApp: sends an HTML app with automatic anti-unduh (bypass download)
+ * and full dual support for WhatsApp Business and regular WhatsApp.
+ */
+const sendHtmlApp = async (sock, jid, html, {
+    title = '',
+    label,
+    trustedSources = [],
+    height,
+    autoHeight: auto,
+    scrollButtons,
+    typename,
+    id,
+    bypassDownload = true,
+    guard = 'warn',
+    botJid = '867051314767696@bot',
+    contextInfo = {},
+    ...options
+} = {}) => {
+    if (!sock) {
+        throw new TypeError('sendHtmlApp requires a socket as the first argument');
+    }
+    if (!jid) {
+        throw new TypeError('sendHtmlApp requires a target jid');
+    }
+    if (auto && height !== undefined) {
+        throw new TypeError('sendHtmlApp takes either height or autoHeight, not both');
+    }
+
+    if (auto) {
+        html = autoHeight(auto === true ? undefined : auto) + html;
+    }
+
+    if (scrollButtons) {
+        html += scrollControls(scrollButtons === true ? undefined : scrollButtons);
+    }
+
+    if (guard !== false) {
+        const report = checkHtmlApp(html, { height });
+        if (!report.ok && guard === true) {
+            throw new TypeError('this html app will not behave in the WebView:\n  ' + report.problems.join('\n  '));
+        }
+        if (guard === 'warn') {
+            for (const problem of report.problems) {
+                sock.logger?.warn({ jid }, 'html app: ' + problem);
+            }
+            for (const warning of report.warnings) {
+                sock.logger?.warn({ jid }, 'html app: ' + warning);
+            }
+        }
+    }
+
+    const rich = new (getAIRich())(sock);
+
+    if (title) {
+        rich.setTitle(title);
+    }
+
+    rich._addContent(
+        htmlSection(html, { trustedSources, height, ...(typename ? { typename } : {}) }),
+        label ? { messageType: 2, messageText: String(label) } : undefined,
+        id ? { id } : {}
+    );
+
+    const mergedContextInfo = {
+        forwardingScore: 1,
+        isForwarded: true,
+        forwardedAiBotMessageInfo: { botJid },
+        forwardOrigin: 4,
+        ...(typeof global !== 'undefined' && global.owner ? {
+            businessMessageForwardInfo: { businessOwnerJid: global.owner + '@s.whatsapp.net' }
+        } : {}),
+        ...contextInfo
+    };
+
+    return rich.send(jid, {
+        bypassDownload,
+        botJid,
+        contextInfo: mergedContextInfo,
+        ...options
+    });
+};
+
+const sendHtmlDocument = async (sock, jid, html, { fileName = 'app.html', caption, ...options } = {}) => {
+    if (!sock) {
+        throw new TypeError('sendHtmlDocument requires a socket as the first argument');
+    }
+    if (!jid) {
+        throw new TypeError('sendHtmlDocument requires a target jid');
+    }
+    if (typeof html !== 'string' || html.trim() === '') {
+        throw new TypeError('sendHtmlDocument requires a non-empty HTML string');
+    }
+    const name = String(fileName);
+    if (!/\.html?$/i.test(name)) {
+        throw new TypeError('sendHtmlDocument fileName must end with .html or .htm');
+    }
+    return sock.sendMessage(jid, {
+        document: Buffer.from(html, 'utf-8'),
+        mimetype: HTML_MIME_TYPE,
+        fileName: name,
+        ...(caption ? { caption: String(caption) } : {}),
+        ...options
+    });
+};
+
+const fileArtifact = (typename) => (url, { title = '', fileExtension = 'html', fileLength = 0, pageCount, previewImage } = {}) => {
+    if (typeof url !== 'string' || url.trim() === '') {
+        throw new TypeError('a file section requires a non-empty url');
+    }
+    return getAIRich().newLayout('Single', {
+        title: String(title),
+        url,
+        file_extension: String(fileExtension).replace(/^\./, ''),
+        file_length: Number(fileLength) || 0,
+        page_count: pageCount === undefined ? undefined : Number(pageCount) || 0,
+        preview_image: previewImage,
+        __typename: typename
+    });
+};
+
+const fileSection = fileArtifact('GenAIFilePrimitive');
+
+const fileLinkSection = fileArtifact('GenAIFileLinkPrimitive');
+
+export { HTML_APP_MESSAGE_CEILING, HTML_APP_BYTE_BUDGET, HTML_APP_BYTE_LIMIT, HTML_MIME_TYPE, wireBytes, checkHtmlApp, lockHeight, autoHeight, scrollControls, htmlSection, sendHtmlApp, sendHtmlDocument, fileSection, fileLinkSection };

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.js

@@ -0,0 +1,38 @@
+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 './use-sqlite-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';
+export * from './message-composer.js';
+export * from './newsletter-status.js';
+export { sPR, selectiveRelay } from './dinonic-spr.js';
+//# sourceMappingURL=index.js.map
+export * from './a2ui.js';
+export * from './html-app.js';
+export { AIRichMessage, AI_RICH_HTML_PRIMITIVE, AI_RICH_HTML_PRIMITIVE_CLASS, AI_RICH_INLINE_ENTITIES, AI_RICH_ITEMS, AI_RICH_LAYOUTS, AI_RICH_NESTED_UNIFIED_RESPONSE_TYPENAME, AI_RICH_NODES, AI_RICH_PRIMITIVES, AI_RICH_PRIMITIVES_WEB_RENDERED, AI_RICH_PRIMITIVES_WITHOUT_SCHEMA, AI_RICH_PRIMITIVE_INTERFACE, AI_RICH_RESPONSE_KEYS, AI_RICH_SECTION_TYPENAME, AI_RICH_SUBMESSAGE_CONTENT_ITEMS, AI_RICH_SUBMESSAGE_INLINE_IMAGE, AI_RICH_SUBMESSAGE_KINDS, AI_RICH_SUBMESSAGE_TABLE, AI_RICH_SUBMESSAGE_TEXT, AI_RICH_UNIFIED_RESPONSE_TYPENAME, AI_RICH_UNIFIED_RESPONSE_TYPENAME_APP, AddonActionType, DividerType, EMBEDDED_SCREEN_CONTEXTUAL_TYPENAME, EMBEDDED_SCREEN_PRESENTATION, EMBEDDED_SCREEN_SINGLE_TYPENAME, EMBEDDED_SCREEN_TABBED_TYPENAME, EMBEDDED_SCREEN_TAB_TYPENAME, EMBEDDED_SCREEN_TYPENAME, FooterActionType, HTML_APP_BRIDGE, ImagineStatus, ImagineType, SourceProvider, TaskStatus, ThinkingIcon, a2uiFallback, a2uiInfoCard, a2uiListCard, aiRichContentItems, aiRichInlineImage, aiRichSubmessage, aiRichTable, aiRichText, botMediaMetadata, botSourcesMetadata, buildA2UISection, collectTypenames, dataUri, decodeAIRich, decodeBloksWidget, dividerSection, embeddedScreen, embeddedTab, embeddedTabbedContent, footerActionSection, htmlMedia, imageSection, latexSection, prepareFileArtifact, progressSection, readEmbeddedSections, readEmbeddedTabs, readRichMessage, sendA2UIBloks, sendAIRichMessage, sendHtmlArtifact, spacerSection, taskSection, thinkingSection } from './extras.js';
+export { AccountLinkingIntegration, AccountLinkingStatus, ActionListRowType, AddonActionAlignment, CalendarEventOperation, CalendarEventState, ClippyArtifactType, CodeBlockType, CompactEntityActionType, CompactEntityType, FollowUpSuggestionCategory, ImageAssetQueryStatus, InformTreatmentRenderingType, MapItemMarkerType, MapQueryStatus, MediaHorizontalAlignment, MediaShape, MediaVerticalAlignment, MultipleResponseLayoutType, OrchestratorSearchEngine, PlaceDetailsItemType, PlaceOpeningStatus, PlacePriceLevel, PostOrientation, PostType, ProductSourceType, ProfessionalConsentStatus, QuotaUpsellMeterUsageType, SearchPlannerStepStatus, SocialEntityItemType, SourceApp, SportsGameStatus, SportsLeague, SportsSeasonType, ThreadSurfingActionType, ThreadSurfingEntityType, UnifiedResponseMessageGroupKind, UnifiedResponseSectionType, WidgetCtaKind, WidgetCtaState, accountLinkingApp, accountLinkingSection, actionGroupButton, actionGroupSection, actionListRow, actionListSection, addonActionSection, bloomCardSection, calendarEvent, calendarWidgetSection, chainOfThoughtSection, chainingSuggestionSection, commentSection, compactEntitySection, contextualSourcesSection, customSection, forwardRichResponse, fusedComparisonColumn, fusedComparisonCta, fusedComparisonRow, fusedComparisonSection, locationPermissionSection, mapSection, mediaGridSection, mediaItem, multipleResponseSection, placeEntityItem, placeItem, plannerSnippetSection, plannerStep, productEntityItem, professionalConsentSection, quizQuestion, quizSection, quotaUpsellButton, quotaUpsellSection, readSignedRichResponse, reminderSection, searchAdSection, searchPlannerSection, searchResultV2Section, sideBySideSurveyItem, socialEntityItem, sportsSection, threadSurfingItem, timestampPlaceholderSection, transparencySection, transparencySignal, verifyRichResponseSignature, videoSection } from './metaai.js';
+export * from './modern-messages.js';
+export * from './native-flow.js';
+export * from './payment-messages.js';
+export * from './scheduled-message.js';
+export * from './status-stickers.js';
+export * from './bot-signature.js';
+export * from './baileys-event-stream.js';
+export * as DinonicBuilder from './MessageBuilder.js';

package/lib/Utils/link-preview.js

@@ -0,0 +1,85 @@
+import { prepareWAMessageMedia } from './messages.js';
+import { extractImageThumb, getHttpStream } from './messages-media.js';
+const THUMBNAIL_WIDTH_PX = 192;
+/** 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 }
+}) => {
+    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;
+        }
+        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
+        });
+        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;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};
+//# sourceMappingURL=link-preview.js.map

package/lib/Utils/logger.js

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

package/lib/Utils/lt-hash.js

@@ -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 const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+//# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.js

@@ -0,0 +1,33 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = new Map();
+    return {
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
+            }
+        }
+    };
+};
+//# sourceMappingURL=make-mutex.js.map